LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyDetector::findLine(unsigned int, bool)
PolyLine *PolyDetector::findLine(uint32_t id, bool useIgnore)
{
    auto search = lineIdToIdx.find(id);
    if (search != lineIdToIdx.end())
    {
        //assert(search->second >= 0 && search->second < lines.size());
        auto &l = lines[search->second];
        if (useIgnore && l.ignore)
        {
            //logoutf("line id %u is ignored!", id);
            return nullptr;
        }
        
        return &l;
    }
    if (search == lineIdToIdx.end())
    {
        logoutf("WARN: line %u can't be found in lineIdToIdx! szFast:%u szLines:%u v:%d", id,
                uint32_t(lineIdToIdx.size()),
                uint32_t(lines.size()),
                search != lineIdToIdx.end() ? search->second : -2);
    }
    
    return nullptr;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %r14
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0x110, %rdi            # imm = 0x110
movq %rax, %rsi
callq 0xaff2
testq %rax, %rax
je 0x4732
movslq 0xc(%rax), %rax
imulq $0x90, %rax, %rbx
addq 0x30(%r14), %rbx
testb %bpl, %bpl
je 0x4767
cmpb $0x0, 0x74(%rbx)
je 0x4767
xorl %ebx, %ebx
jmp 0x4767
movl 0xc(%rsp), %esi
movl 0x128(%r14), %ecx
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
movl $0x90, %edi
cqto
idivq %rdi
leaq 0x9148(%rip), %rdi      # 0xd89e
xorl %ebx, %ebx
pushq $-0x2
popq %r8
movl %ecx, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x2040
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::numNeigh(PolyDetector&) const
uint32_t PolyLine::numNeigh(PolyDetector &pd) const
{
    auto search = pd._neighbors.find(id);
    if (search == pd._neighbors.end())
        return 0;
    uint32_t ret = 0;
    for (auto &n : search->second)
    {
        auto l = pd.findLine(n);
        if (l)
            ret++;
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
leaq 0x68(%rsi), %rax
leaq 0x60(%rdi), %rsi
movq %rax, %rdi
callq 0xac48
leaq 0x70(%rbx), %rcx
cmpq %rcx, %rax
je 0x47c6
movq 0x28(%rax), %r15
movq 0x30(%rax), %r12
xorl %ebp, %ebp
pushq $0x1
popq %r14
cmpq %r12, %r15
je 0x47c8
movl (%r15), %esi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x46ec
cmpq $0x1, %rax
sbbl $-0x1, %ebp
addq $0x4, %r15
jmp 0x47a6
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyPol::Minus(PolyPol const&)
bool PolyPol::Minus(const PolyPol &other)
{
    for (auto itOther = other.p.begin(); itOther != other.p.end(); ++itOther)
    {
        for (auto it = p.begin(); it != p.end();)
        {
            if (!pointsDiffer(*itOther, *it))
            {
                it = p.erase(it);
            }
            else
                ++it;
        }
    }
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movss 0x77e0(%rip), %xmm2     # 0xd060
cmpq 0x8(%rbx), %r15
je 0x58d5
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x58cf
movss (%r15), %xmm0
subss (%rax), %xmm0
movss 0x4(%r15), %xmm1
subss 0x4(%rax), %xmm1
mulss %xmm1, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
ucomiss %xmm2, %xmm0
jae 0x58c9
movq %r14, %rdi
movq %rax, %rsi
callq 0x8900
movss 0x7799(%rip), %xmm2     # 0xd060
jmp 0x5889
addq $0x8, %rax
jmp 0x5889
addq $0x8, %r15
jmp 0x5880
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyPol::CalculateFirstAndLastPoint()
void PolyPol::CalculateFirstAndLastPoint()
{
    // if there are only one vertex it is not a polyline
    if (p.size() < 2)
    {
        p.clear();
        return;
    }
    
    /*
    if (!IsClosed())
    {
        p.clear();
        return;
    }
    */
    
    // the case of the closed polyline
    // here we're going to find the first point by seeing them all
    //Point2D *vertex=NULL, *first_vertex=_vertex_array[0];
    PointType *firstVertex = nullptr;
    for (size_t i = 0; i < p.size(); ++i)
    {
        auto &vertex = p[i];
        if (!firstVertex || !bComparePointOrder(*firstVertex, vertex))
        {
            firstVertex = &vertex;
            firstIdx = i;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
movq %rax, %r12
subq %r14, %r12
sarq $0x3, %r12
cmpq $0x2, %r12
jae 0x5914
cmpq %r14, %rax
je 0x590a
movq %r14, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r13, %r12
je 0x590a
testq %r15, %r15
je 0x5933
movq %r15, %rdi
movq %r14, %rsi
callq 0x4562
testb %al, %al
jne 0x593a
movq %r13, 0x18(%rbx)
movq %r14, %r15
incq %r13
addq $0x8, %r14
jmp 0x591a
nop
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::betweenNeighbors(PolyDetector&, PolyLine const&, PolyLine const&) const
bool PolyLine::betweenNeighbors(PolyDetector &pd, const PolyLine &l1, const PolyLine &l2) const
{
    auto cpid = commonPid(l1);
    if (cpid < 0)
    {
        //logoutf("l1: cpid %d between %u and %u", cpid, id, l1.id);
        //logoutf("%s %s", toString(pd).c_str(), l1.toString(pd).c_str());
        return false;
    }
    auto cpid2 = commonPid(l2);
    if (cpid != cpid2)
    {
        //logoutf("l2: cpid %d between %u and %u", cpid2, id, l2.id);
        return false;
    }
    
    //auto &p1 =  pd.intersectionPoints[l1.otherPid(cpid)];
    //auto &p2 =  pd.intersectionPoints[l2.otherPid(cpid)];
    
    vec cp = pd.intersectionPoints[cpid];
    vec p = pd.intersectionPoints[otherPid(cpid)];

    //bool ret = obb::Line(cp, cp.sub(p).normalize()).Intersects(obb::LineSegment(l1.center, l2.center));
    bool ret = doIntersect(cp, p, l1.center, l2.center);
    
    if (ret)
    {
        if (pd.verbose > 2)
        {
            //logoutf("line %s is between %s and %s (commonP: P%d)", toString(pd).c_str(), l1.toString(pd).c_str(), l2.toString(pd).c_str(), cpid);
            logoutf("line %u is between %u and %u (commonP: P%d)", id, l1.id, l2.id, cpid);
        }
    }
    else
    {
        //logoutf("line %u is NOT between %u and %u (commonP: P%d)", id, l1.id, l2.id, cpid);
    }
    
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rsi
callq 0x8b7c
testl %eax, %eax
js 0x5fbe
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8b7c
cmpl %eax, %ebp
jne 0x5fbe
movl %ebp, %eax
movq 0xc8(%r12), %rcx
movq (%rcx,%rax,8), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movl 0x80(%r15), %eax
cmpl %ebp, %eax
cmovel 0x84(%r15), %eax
movq (%rcx,%rax,8), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x58(%r14), %rdx
leaq 0x58(%rbx), %rcx
callq 0x2419
movl %eax, %r13d
testb %al, %al
je 0x5fc1
cmpl $0x3, 0x60(%r12)
jb 0x5fc1
movl 0x60(%r15), %esi
movl 0x60(%r14), %edx
movl 0x60(%rbx), %ecx
leaq 0x7acc(%rip), %rdi      # 0xda7e
movl %ebp, %r8d
xorl %eax, %eax
callq 0x2040
jmp 0x5fc1
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyCycle::accepted(PolyDetector&)
bool PolyCycle::accepted(PolyDetector &pd)
{
    for (auto &lid : idx)
    {
        auto l = pd.findLine(lid);
        if (l)
        {
            l->incTook(pd);
            l->processed = startIdx + 1;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
leaq 0x8(%rdi), %r12
pushq $0x1
popq %rbp
cmpq %r12, %r15
je 0x6028
movl 0x20(%r15), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x46ec
testq %rax, %rax
je 0x601b
movl 0x78(%rax), %ecx
cmpl $0x1, %ecx
ja 0x6012
incl %ecx
movl %ecx, 0x78(%rax)
movl 0x30(%r14), %ecx
incl %ecx
movl %ecx, 0x7c(%rax)
movq %r15, %rdi
callq 0x2160
movq %rax, %r15
jmp 0x5fed
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::compareNeigh(PolyDetector&, unsigned int, unsigned int) const
bool PolyLine::compareNeigh(PolyDetector &pd, uint32_t nid1, uint32_t nid2) const
{
    auto nl1 = pd.findLine(nid1);
    auto nl2 = pd.findLine(nid2);
    if (!nl1 || !nl2)
    {
        assert(false);
        return true;
    }
    
#if 1
    auto dl1 = nl1->center.squaredist(center);
    auto dl2 = nl2->center.squaredist(center);
    return dl1 < dl2;
#elif 0
    return PolyLine::bCompareLineOrder(*nl1, *nl2);
#else
    return angle(pd, *nl1) < angle(pd, *nl2);
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x1
popq %r12
movq %rsi, %rdi
movl %edx, %esi
movl %r12d, %edx
callq 0x46ec
movq %rax, %r14
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x46ec
testq %r14, %r14
je 0x6460
testq %rax, %rax
je 0x6460
movups 0x58(%rbx), %xmm0
movups 0x5c(%rbx), %xmm1
movss 0x58(%rax), %xmm2
movss 0x5c(%rax), %xmm3
movss 0x58(%r14), %xmm4
unpcklps %xmm2, %xmm4            # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
movss 0x5c(%r14), %xmm2
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
subps %xmm0, %xmm4
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
subps %xmm1, %xmm2
mulps %xmm2, %xmm2
mulps %xmm4, %xmm4
addps %xmm2, %xmm4
movaps %xmm4, %xmm0
shufps $0x55, %xmm4, %xmm0     # xmm0 = xmm0[1,1],xmm4[1,1]
ucomiss %xmm4, %xmm0
seta %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7644(%rip), %rdi      # 0xdaab
leaq 0x6ca6(%rip), %rsi      # 0xd114
leaq 0x763c(%rip), %rcx      # 0xdab1
movl $0x7a0, %edx            # imm = 0x7A0
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::sortNeigh(PolyDetector&) const
bool PolyLine::sortNeigh(PolyDetector &pd) const
{
    auto &neigh = pd._neighbors[id];
    std::sort(neigh.begin(), neigh.end(), [this, &pd](uint32_t nid1, uint32_t nid2)
    {
        return compareNeigh(pd, nid1, nid2);
    });
    
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rsi), %rdi
leaq 0x60(%r14), %rsi
callq 0x875e
movq (%rax), %r12
movq 0x8(%rax), %r15
cmpq %r15, %r12
je 0x6519
movq %r15, %r13
subq %r12, %r13
movq %r13, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
movq %rbx, %r8
callq 0x7962
cmpq $0x41, %r13
jl 0x6508
leaq 0x40(%r12), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x7c9b
cmpq %r15, %r13
je 0x6519
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7d35
addq $0x4, %r13
jmp 0x64ef
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x7c9b
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::setIgnore(PolyDetector&, char const*)
void PolyLine::setIgnore(PolyDetector &pd, const char *msg)
{
    if (ignore)
        return;
    
    if (pd.verbose)
        logoutf("[%s] ignore line %s", msg, toString(pd).c_str());
    
    ignore = true;
}

// Assembly:
cmpb $0x0, 0x74(%rdi)
jne 0x6de1
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
cmpl $0x0, 0x60(%rsi)
je 0x6dd4
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4208
movq (%r15), %rdx
leaq 0x707a(%rip), %rdi      # 0xde3c
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
callq 0x20b0
movb $0x1, 0x74(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyDetector::dissolveCollinearLine(PolyLine&)
bool PolyDetector::dissolveCollinearLine(PolyLine &l)
{
    for (auto id : {l.aIdx, l.bIdx})
    {
        uint32_t nValid = 0;
        PolyLine *l1 = nullptr;
        for (auto &n : pointToLines[id])
        {
            if (n != l.id)
            {
                auto lPtr = findLine(n);
                if (lPtr)
                {
                    if (lPtr->took < 2)
                    //if (lPtr->took == 0)
                    //if (lPtr->numNeigh(*this) < 2)
                    {
                        l1 = lPtr;
                        nValid++;
                    }
                }
            }
        }
        //if (nValid == 1)
        //if (nValid > 0)
        //{
        //    logoutf("CollinearIdx[P%u](%s, %s)) = %d. nValid:%u", id, l.toString(*this).c_str(), l1->toString(*this).c_str(), CollinearIdx(l, *l1), nValid);
        //}
        if (nValid == 1 && CollinearIdx(l, *l1))
        {
            if (verbose)
                logoutf("line %s -> P%u has 2 intersections. otherLine:%u", l.toString(*this).c_str(), id, l1->id);
            return dissolveCollinear(l, *l1);
        }
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rsi), %rax
movq %rax, 0x20(%rsp)
leaq 0xe0(%rdi), %rax
movq %rax, 0x18(%rsp)
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x6eed
movq %rcx, 0x10(%rsp)
movl 0x20(%rsp,%rcx), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x875e
movq (%rax), %r12
movq 0x8(%rax), %rbp
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %rbp, %r12
je 0x6e78
movl (%r12), %esi
cmpl 0x60(%rbx), %esi
je 0x6e72
movq %r14, %rdi
pushq $0x1
popq %rdx
callq 0x46ec
testq %rax, %rax
je 0x6e72
movl 0x78(%rax), %ecx
cmpl $0x2, %ecx
adcl $0x0, %r13d
cmpl $0x2, %ecx
cmovbq %rax, %r15
addq $0x4, %r12
jmp 0x6e43
cmpl $0x1, %r13d
jne 0x6e90
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5f0e
testb %al, %al
jne 0x6e9e
movq 0x10(%rsp), %rcx
addq $0x4, %rcx
jmp 0x6e10
cmpl $0x0, 0x60(%r14)
je 0x6eda
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4208
movq (%r12), %rsi
movl 0xc(%rsp), %edx
movl 0x60(%r15), %ecx
leaq 0x6e7c(%rip), %rdi      # 0xdd47
xorl %eax, %eax
callq 0x2040
movq %r12, %rdi
callq 0x20b0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x68b6
movq 0x10(%rsp), %rcx
cmpq $0x8, %rcx
setne %cl
andb %al, %cl
movl %ecx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyDetector::CollinearIdx(unsigned int, unsigned int)
bool PolyDetector::CollinearIdx(uint32_t l1, uint32_t l2)
{
    auto search = collinearLineMap.find(l1);
    if (search == collinearLineMap.end())
        return false;
    return std::find(search->second.begin(), search->second.end(), l2) != search->second.end();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
movl %edx, (%rsp)
addq $0x98, %rdi
movq %rax, %rsi
callq 0xac48
addq $0xa0, %r14
cmpq %r14, %rax
je 0x7120
movq %rax, %rbx
movq 0x28(%rax), %rdi
movq 0x30(%rax), %rsi
movq %rsp, %rdx
callq 0x9d20
cmpq 0x30(%rbx), %rax
setne %al
jmp 0x7122
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyDetector::rmEarPoints()
bool PolyDetector::rmEarPoints()
{
    std::vector<PolyLine *> torm;
    
    std::set<uint32_t> pids;
    for (auto &cycle : _cycles)
    {
        for (auto &lid : cycle.idx)
        {
            auto l = findLine(lid);
            if (l)
            {
                for (auto &pid : {l->aIdx, l->bIdx})
                {
                    if (cycle.pointConsumed(*this, pid))
                    {
                        if (verbose)
                            logoutf("Point P%u is an ear! will remove line %u", pid, l->id);
                        torm.push_back(l);
                    }
                }
            }
        }
    }
    //if (verbose)
    //    logoutf("cyclePids:%u/%u", uint32_t(pids.size()), uint32_t(intersectionPoints.size()));
            
    for (auto &l : torm)
    {
        l->setIgnore(*this, "rmEarPoints");
    }
        
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x10(%rsp), %rcx
andq $0x0, 0x10(%rcx)
leaq 0x50(%rsp), %rax
andl $0x0, (%rax)
movq %rdi, %rbx
andq $0x0, 0x8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq (%rdi), %r15
movq 0x8(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0x8(%rsp), %r12
cmpq 0x30(%rsp), %r15
je 0x7364
movq 0x18(%r15), %rbp
leaq 0x8(%r15), %rax
movq %rax, 0x38(%rsp)
cmpq 0x38(%rsp), %rbp
je 0x735b
movl 0x20(%rbp), %esi
movq %rbx, %rdi
pushq $0x1
popq %rdx
callq 0x46ec
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x734b
movq 0x80(%rax), %rax
movq %rax, 0x40(%rsp)
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x734b
movl 0x40(%rsp,%r14), %r13d
movq %r15, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x712a
testb %al, %al
je 0x7345
cmpl $0x0, 0x60(%rbx)
je 0x7338
movq 0x8(%rsp), %rax
movl 0x60(%rax), %edx
leaq 0x6b23(%rip), %rdi      # 0xde51
movl %r13d, %esi
xorl %eax, %eax
callq 0x2040
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x8d7e
addq $0x4, %r14
jmp 0x72fc
movq %rbp, %rdi
callq 0x2160
movq %rax, %rbp
jmp 0x72ca
addq $0x40, %r15
jmp 0x72b2
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r12
leaq 0x6b06(%rip), %r14      # 0xde7b
cmpq %r12, %r15
je 0x738e
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6d8c
addq $0x8, %r15
jmp 0x7375
leaq 0x48(%rsp), %rdi
callq 0x96fe
leaq 0x10(%rsp), %rdi
callq 0xb8c4
movb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x73b7
jmp 0x73b7
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x96fe
leaq 0x10(%rsp), %rdi
callq 0xb8c4
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyDetector::reset()
void PolyDetector::reset()
{
    _cycles.clear();
    //processed.clear();
    origLines.clear();
    lines.clear();
    polys.clear();
    _neighbors.clear();
    collinearLineMap.clear();
    intersectionPoints.clear();
    pointToLines.clear();
    dissolveCount = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8d76
leaq 0x18(%rbx), %rdi
callq 0x8750
leaq 0x30(%rbx), %rdi
callq 0x8750
leaq 0x48(%rbx), %rdi
callq 0x88f8
leaq 0x68(%rbx), %rdi
callq 0x9eae
leaq 0x98(%rbx), %rdi
callq 0x9eae
movq 0xc8(%rbx), %rax
cmpq %rax, 0xd0(%rbx)
je 0x7426
movq %rax, 0xd0(%rbx)
leaq 0xe0(%rbx), %rdi
callq 0x9eae
andl $0x0, 0x148(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: orientation(vec const&, vec const&, vec const&)
static int orientation(const PointType &p, const PointType &q, const PointType &r)
{
    // See https://www.geeksforgeeks.org/orientation-3-ordered-points/
    // for details of below formula.
    double val =
            (q.y - p.y) * (r.x - q.x) -
            (q.x - p.x) * (r.y - q.y);
  
    if (val == 0.0) return 0;  // colinear
    //if (abs(val) <= 1e-7f) return 0;  // colinear
  
    return (val > 0) ? 1: 2; // clock or counterclock wise
}

// Assembly:
movss 0x4(%rsi), %xmm0
movss 0x4(%rdx), %xmm1
subss %xmm0, %xmm1
subss 0x4(%rdi), %xmm0
movss (%rsi), %xmm2
movss (%rdx), %xmm3
subss %xmm2, %xmm3
mulss %xmm0, %xmm3
subss (%rdi), %xmm2
mulss %xmm2, %xmm1
subss %xmm1, %xmm3
xorps %xmm0, %xmm0
xorl %ecx, %ecx
ucomiss %xmm0, %xmm3
setbe %cl
incl %ecx
xorl %eax, %eax
ucomiss %xmm0, %xmm3
cmovnel %ecx, %eax
cmovpl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: onSegment(vec const&, vec const&, vec const&)
static bool onSegment(const PointType &p, const PointType &q, const PointType &r)
{
    if (q.x <= std::max(p.x, r.x) && q.x >= std::min(p.x, r.x) &&
        q.y <= std::max(p.y, r.y) && q.y >= std::min(p.y, r.y))
       return true;
  
    return false;
}

// Assembly:
movss (%rsi), %xmm0
movss (%rdi), %xmm1
movss (%rdx), %xmm2
movaps %xmm2, %xmm3
maxss %xmm1, %xmm3
ucomiss %xmm0, %xmm3
jb 0x74d7
minss %xmm1, %xmm2
ucomiss %xmm2, %xmm0
jb 0x74d7
movss 0x4(%rsi), %xmm0
movss 0x4(%rdi), %xmm2
movss 0x4(%rdx), %xmm1
movaps %xmm1, %xmm3
maxss %xmm2, %xmm3
ucomiss %xmm0, %xmm3
jb 0x74d7
minss %xmm2, %xmm1
movb $0x1, %al
ucomiss %xmm1, %xmm0
jae 0x74d9
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/./PolyDetector.h
// Function: PolyCycle::idxToString[abi:cxx11]() const
std::string idxToString() const
    {
        std::string str;
        for (auto &n : idx)
        {
            str += std::to_string(n) + " ";
        }
        if (!str.empty())
            str.pop_back();
        return str;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x18(%rsi), %r12
addq $0x8, %r14
leaq 0x8(%rsp), %r15
leaq 0x50b0(%rip), %r13      # 0xda58
leaq 0x28(%rsp), %rbp
cmpq %r14, %r12
je 0x89f5
movl 0x20(%r12), %esi
movq %r15, %rdi
callq 0x87e9
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x87ca
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2220
movq %rbp, %rdi
callq 0x20b0
movq %r15, %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x2160
movq %rax, %r12
jmp 0x89ad
cmpq $0x0, 0x8(%rbx)
je 0x8a04
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x8a37
movq %rax, %r14
jmp 0x8a2d
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/realuptime[P]PolyDetector/./PolyDetector.h
// Function: PolyCycle::toString[abi:cxx11]() const
std::string toString() const
    {
        std::string str = "C{[" + std::to_string(startIdx) + "] nLines:";
        str += std::to_string(idx.size());
        
        str += " [";
        str += idxToString();
        str += "]}";
        
        return str;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x30(%rsi), %esi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x87e9
leaq 0x52a7(%rip), %rsi      # 0xdf07
movq %rsp, %rdi
movq %r15, %rdx
callq 0x88d3
leaq 0x5299(%rip), %rdx      # 0xdf0b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x87ca
movq %rsp, %rdi
callq 0x20b0
leaq 0x20(%rsp), %rdi
callq 0x20b0
movq 0x28(%r14), %rsi
movq %rsp, %rdi
callq 0x9610
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2220
movq %rsp, %rdi
callq 0x20b0
leaq 0x4a81(%rip), %rsi      # 0xd736
movq %rbx, %rdi
callq 0x2210
movq %rsp, %rdi
movq %r14, %rsi
callq 0x8970
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2220
movq %rsp, %rdi
callq 0x20b0
leaq 0x5233(%rip), %rsi      # 0xdf15
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8cfb
jmp 0x8d21
movq %rax, %r14
movq %rsp, %rdi
callq 0x20b0
jmp 0x8d24
jmp 0x8d21
movq %rax, %r14
movq %rsp, %rdi
callq 0x20b0
jmp 0x8d1a
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x8d27
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/bloom.c
// Function: bloom_create
BLOOM *
bloom_create(int hash_bits, int npoints, int point_bits)
{
    if (hash_bits <= 0 || npoints <= 0 || npoints & (npoints - 1)
        || point_bits > 8 || point_bits & (point_bits - 1))
        return NULL;
        //XXX for bitfields change calloc(npoints,1) to calloc(npoints*point_bits/8 + 1,1)
    int wid = bitwid(npoints);
    BLOOM *bp = (BLOOM *) malloc(sizeof *bp);
    *bp = (BLOOM){ hash_bits, npoints, point_bits, wid, (1 << wid) - 1,
                   (1 << point_bits) - 1, (uint8_t *) calloc(npoints,1), MIN_OVFL_LIMIT, 0,
                   (OVFL *) calloc(MIN_OVFL_LIMIT, sizeof(OVFL)) };
    return bp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %edi, %edi
setle %al
testl %esi, %esi
setle %cl
orb %al, %cl
je 0x3848
xorl %r15d, %r15d
jmp 0x391e
movl %edx, %ebx
xorl %r15d, %r15d
cmpl $0x8, %edx
jg 0x391e
movl %esi, %r14d
leal 0x7fffffff(%r14), %eax
andl %esi, %eax
jne 0x391e
movl %ebx, %eax
shrl %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl %ebx, %ecx
subl %eax, %ecx
movl $0x33333333, %eax       # imm = 0x33333333
movl %ecx, %edx
andl %eax, %edx
shrl $0x2, %ecx
andl %eax, %ecx
addl %edx, %ecx
movl %ecx, %eax
shrl $0x4, %eax
addl %ecx, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
imull $0x1010101, %eax, %eax  # imm = 0x1010101
shrl $0x18, %eax
cmpl $0x1, %eax
ja 0x391e
movl %edi, %ebp
movl %r14d, %edi
callq 0x404a
movl %eax, %r15d
movl %eax, 0xc(%rsp)
pushq $0x30
popq %rdi
callq 0x3240
pushq $-0x1
popq %r12
movl %r12d, %r13d
movl %r15d, %ecx
shll %cl, %r13d
movl %ebx, %ecx
shll %cl, %r12d
movq %rax, %r15
notl %r13d
notl %r12d
movl %r14d, %edi
pushq $0x1
popq %rsi
callq 0x3110
movq %rax, 0x10(%rsp)
pushq $0x7
popq %rdi
pushq $0x8
popq %rsi
callq 0x3110
movl %ebp, (%r15)
movl %r14d, 0x4(%r15)
movl %ebx, 0x8(%r15)
movl 0xc(%rsp), %ecx
movl %ecx, 0xc(%r15)
movl %r13d, 0x10(%r15)
movl %r12d, 0x14(%r15)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%r15)
movq $0x7, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/bloom.c
// Function: bloom_add
void
bloom_add(BLOOM *bp, char const *hash)
{
    int bitoff;
    FOR_CHUNKS(bitoff, bp) {
        int pt = CHUNK(bp, hash, bitoff);
        if (point_val(bp, pt) < bp->point_max)
            point_inc(bp, pt);
        else ovfl_inc(bp, pt);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %eax
xorl %ebp, %ebp
pushq $0x4
popq %r12
movq %rsi, 0x10(%rsp)
movl (%r14), %ecx
subl %eax, %ecx
cmpl %ecx, %ebp
jg 0x3a57
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x3a66
movl %eax, %r13d
movq 0x18(%r14), %rax
movslq %r13d, %rcx
movzbl (%rax,%rcx), %edx
cmpl %edx, 0x14(%r14)
jle 0x39af
incb %dl
movb %dl, (%rax,%rcx)
jmp 0x3a4c
movl 0x20(%r14), %r15d
imull $0x5, 0x24(%r14), %eax
cltd
idivl %r12d
cmpl %eax, %r15d
jg 0x3a24
movl %r13d, 0xc(%rsp)
movq 0x28(%r14), %r13
leal 0x1(,%r15,2), %eax
movl %eax, 0x20(%r14)
movslq %eax, %rdi
pushq $0x8
popq %rsi
callq 0x3110
movq %rax, 0x28(%r14)
testl %r15d, %r15d
js 0x3a0e
movq 0x28(%r14), %rbx
movl %r15d, %r12d
movl (%r13,%r12,8), %esi
movq %r14, %rdi
callq 0x3d30
cltq
movq (%r13,%r12,8), %rcx
movq %rcx, (%rbx,%rax,8)
decl %r15d
jmp 0x39e5
movq %r13, %rdi
callq 0x3210
movq 0x10(%rsp), %rbx
pushq $0x4
popq %r12
movl 0xc(%rsp), %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0x3d30
movq 0x28(%r14), %rcx
cltq
movl 0x4(%rcx,%rax,8), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x4(%rcx,%rax,8)
testl %edx, %edx
jne 0x3a4c
movl %r13d, (%rcx,%rax,8)
incl 0x24(%r14)
movl 0xc(%r14), %eax
addl %eax, %ebp
jmp 0x3977
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/bloom.c
// Function: bloom_del
void
bloom_del(BLOOM *bp, char const *hash)
{
    int bitoff;
    FOR_CHUNKS(bitoff, bp) {
        int pt = CHUNK(bp, hash, bitoff);
        if (point_val(bp, pt) < bp->point_max || ovfl_dec(bp, pt))
            point_dec(bp, pt);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movl 0xc(%rdi), %eax
xorl %ebx, %ebx
movl (%r14), %ecx
subl %eax, %ecx
cmpl %ecx, %ebx
jg 0x3b50
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movl %ebx, 0xc(%rsp)
movl %ebx, %edx
callq 0x3a66
movq 0x18(%r14), %r13
movslq %eax, %rbx
movzbl (%r13,%rbx), %ebp
cmpl %ebp, 0x14(%r14)
jg 0x3b39
movq %r14, %rdi
movl %eax, %esi
callq 0x3d30
movl %eax, %r15d
movq 0x28(%r14), %r12
cltq
movl 0x4(%r12,%rax,8), %ecx
testl %ecx, %ecx
je 0x3b39
decl %ecx
movl %ecx, 0x4(%r12,%rax,8)
movl 0xc(%rsp), %ebx
jne 0x3b45
decl 0x24(%r14)
movslq 0x20(%r14), %r13
movslq %r15d, %r15
incq %r15
andq %r13, %r15
cmpl $0x0, 0x4(%r12,%r15,8)
je 0x3b45
movl (%r12,%r15,8), %esi
movq %r14, %rdi
callq 0x3d30
cmpl %r15d, %eax
je 0x3b01
cltq
movq (%r12,%r15,8), %rcx
movq %rcx, (%r12,%rax,8)
movq 0x28(%r14), %r12
andl $0x0, 0x4(%r12,%r15,8)
jmp 0x3afd
decb %bpl
movb %bpl, (%r13,%rbx)
movl 0xc(%rsp), %ebx
movl 0xc(%r14), %eax
addl %eax, %ebx
jmp 0x3a9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/bloom.c
// Function: bloom_chk
int
bloom_chk(BLOOM const*bp, char const *hash)
{
    int bitoff;
    FOR_CHUNKS(bitoff, bp)
        if (!point_val(bp, CHUNK(bp, hash, bitoff)))
            return 0;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %r12d
movl 0xc(%rdi), %r13d
subl %r13d, %r12d
xorl %ebp, %ebp
pushq $0x1
popq %rbx
cmpl %r12d, %ebp
jg 0x3ba4
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3a66
movq 0x18(%r15), %rcx
cltq
cmpb $0x0, (%rcx,%rax)
je 0x3ba2
addl %r13d, %ebp
jmp 0x3b7f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/bloom.c
// Function: bloom_dump
void
bloom_dump(BLOOM const *bp, FILE *fp)
{
    fprintf(fp, "{ hash_bits:%d npoints:%d point_bits:%d"
                    " hash_chunk:%d hash_mask:%d point_max:%d"
                    " ovfl_limit:%d ovfl_count:%d"
                "\n  pointv:( ",
                bp->hash_bits, bp->npoints, bp->point_bits,
                bp->hash_chunk, bp->hash_mask, bp->point_max,
                bp->ovfl_limit, bp->ovfl_count);
    int i, val;
    for (i = 0; i < bp->npoints; ++i)
        if ((val = point_val(bp, i)))
            fprintf(fp, "%s[%d]:%d ", !i || i%10 ? "" : "\n\t\t", i,
                    val + bp->ovfl[ovfl_find(bp,i)].count);

    fputs(")\n  ovfl:{", fp);
    for (i = 0; i <= bp->ovfl_limit; ++i)
        if (bp->ovfl[i].count)
            fprintf(fp, " %d:%d", bp->ovfl[i].point, bp->ovfl[i].count);

    fputs(" }\n}\n", fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edx
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0xc(%rdi), %r9d
movl 0x10(%rdi), %r10d
movl 0x14(%rdi), %r11d
movl 0x20(%rdi), %r15d
movl 0x24(%rdi), %r12d
leaq 0x24d4(%rip), %rsi      # 0x6100
movq %rbx, %rdi
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r11
pushq %r10
callq 0x3280
addq $0x20, %rsp
xorl %r12d, %r12d
movq %rbx, (%rsp)
movl %r12d, %eax
xorl %edx, %edx
pushq $0xa
popq %rcx
divl %ecx
movslq 0x4(%r14), %rcx
cmpq %rcx, %r12
jge 0x3cce
movq 0x18(%r14), %rcx
movzbl (%rcx,%r12), %ebp
testl %ebp, %ebp
je 0x3cc6
testq %r12, %r12
je 0x3c89
imull $-0xa, %eax, %eax
leaq 0x250b(%rip), %r13      # 0x6183
addl %r12d, %eax
je 0x3c84
leaq 0x2502(%rip), %r13      # 0x6186
movl %r12d, %r15d
jmp 0x3c93
xorl %r15d, %r15d
leaq 0x24f3(%rip), %r13      # 0x6186
movq 0x28(%r14), %rbx
movq %r14, %rdi
movl %r15d, %esi
callq 0x3d30
cltq
addl 0x4(%rbx,%rax,8), %ebp
movq (%rsp), %rbx
movq %rbx, %rdi
leaq 0x24c2(%rip), %rsi      # 0x6178
movq %r13, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3280
incq %r12
jmp 0x3c49
leaq 0x24b2(%rip), %rdi      # 0x6187
movq %rbx, %rsi
callq 0x31e0
leaq 0x24ae(%rip), %r15      # 0x6192
xorl %r12d, %r12d
movslq 0x20(%r14), %rax
cmpq %rax, %r12
jg 0x3d13
movq 0x28(%r14), %rax
movl 0x4(%rax,%r12,8), %ecx
testl %ecx, %ecx
je 0x3d0e
movl (%rax,%r12,8), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3280
incq %r12
jmp 0x3ce7
leaq 0x247f(%rip), %rdi      # 0x6199
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/bloom.c
// Function: ovfl_find
static int
ovfl_find(BLOOM const*bp, int point)
{
    int i;
    for (i = point;; ++i) {
        i &= bp->ovfl_limit;
        if (!bp->ovfl[i].count || bp->ovfl[i].point == point)
            return i;
    }
}

// Assembly:
movslq 0x20(%rdi), %rcx
movq 0x28(%rdi), %rdx
movl %esi, %eax
cltq
andq %rcx, %rax
cmpl $0x0, 0x4(%rdx,%rax,8)
je 0x3d4f
cmpl %esi, (%rdx,%rax,8)
je 0x3d4f
incl %eax
jmp 0x3d3a
retq
// File: /workspace/github_cpp_makefile_star2_O2/TheZoq2[P]sweplusplus/sv.cpp
// Function: main
hel hufvud(hel arga, vidbränd dubbelpekare argv)
{
    bil i = 0;
    vidbränd dubbelpekare nuvarande = argv;

    medans (i < arga) {
        placeras(dereferera nuvarande);
        nuvarande++;
        i ökas_med_ett;
        om (i == 3) {
            uppfostra Barn("För många argument");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %r14d
xorl %r15d, %r15d
testl %edi, %edi
cmovlel %r15d, %r14d
cmpl %r15d, %r14d
je 0x12b6
movq (%rbx,%r15,8), %rdi
callq 0x10c0
incq %r15
cmpl $0x3, %r15d
jne 0x1258
pushq $0x20
popq %rdi
callq 0x1050
movq %rax, %rbx
leaq 0xd83(%rip), %rsi       # 0x2004
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x12ea
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x10a0
xorl %r15d, %r15d
leaq 0x2b09(%rip), %rsi      # 0x3db0
leaq 0x78(%rip), %rdx        # 0x1326
movq %rbx, %rdi
callq 0x10d0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x1040
testb %r15b, %r15b
jne 0x12d9
jmp 0x12e1
movq %rax, %r14
movq %rbx, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x10e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/eecs280staff[P]unit_test_framework/test/size_t_and_int.cpp
// Function: size_t_and_int()
TEST(size_t_and_int) {
  std::size_t s = 3u;
  int i1 = -1;
  int i2 = 3;
  ASSERT_NOT_EQUAL(s, i1);
  ASSERT_NOT_EQUAL(i1, s);
  ASSERT_EQUAL(s, i2);
  ASSERT_EQUAL(i2, s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x4(%rsp), %r15
orl $-0x1, (%r15)
leaq 0x8(%rsp), %rbx
movq $0x3, (%rbx)
movq %rsp, %r14
movl $0x3, (%r14)
leaq 0x2b22(%rip), %rcx      # 0x503d
pushq $0x7
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2cd4
leaq 0x2b25(%rip), %rcx      # 0x5055
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2e00
leaq 0x2b28(%rip), %rcx      # 0x506d
pushq $0x9
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f2c
leaq 0x2b27(%rip), %rcx      # 0x5081
pushq $0xa
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3048
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/IsseW[P]bytepusher/src/grid/grid.cpp
// Function: Grid::update_with_rule(void (*)(Grid&, unsigned int, unsigned int))
void Grid::update_with_rule(void (*rule)(Grid&, uint32_t x, uint32_t y)) {
  for (uint32_t y = 0; y < height; y++) {
    for (uint32_t x = 0; x < width; x++) {
      rule(*this, x, y);
    }
  }
  swap();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl 0x4(%rbx), %ebp
jae 0x2868
xorl %r15d, %r15d
cmpl (%rbx), %r15d
jae 0x2864
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq *%r14
incl %r15d
jmp 0x284f
incl %ebp
jmp 0x2847
movdqu 0x8(%rbx), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/IsseW[P]bytepusher/src/grid/grid.cpp
// Function: Grid::print()
void Grid::print() {
  for (uint32_t y = 0; y < height; y++) {
    for (uint32_t x = 0; x < width; x++) {
      std::cout << (get(x, y) == Tile::Alive ? '#' : '.');
    }
    std::cout << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
pushq $0x23
popq %r12
pushq $0x2e
popq %r13
movq 0x2719(%rip), %r14      # 0x4fd8
cmpl 0x4(%rbx), %ebp
jae 0x28fb
xorl %r15d, %r15d
cmpl (%rbx), %r15d
jae 0x28ef
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x290a
cmpb $-0x1, %al
movl %r13d, %esi
cmovel %r12d, %esi
movq %r14, %rdi
callq 0x2190
incl %r15d
jmp 0x28c7
movq %r14, %rdi
callq 0x20d0
incl %ebp
jmp 0x28bf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/IsseW[P]bytepusher/src/grid/grid.cpp
// Function: Grid::count_neighbors(unsigned int, unsigned int, Tile, unsigned int)
uint32_t Grid::count_neighbors(uint32_t x, uint32_t y, Tile to_count,
                               uint32_t extent) {

  uint32_t min_x = std::max<int32_t>(x - extent, 0);
  uint32_t max_x = std::min<int32_t>(x + extent, width - 1);
  uint32_t min_y = std::max<int32_t>(y - extent, 0);
  uint32_t max_y = std::min<int32_t>(y + extent, height - 1);

  uint32_t count = 0;
  for (uint32_t _y = min_y; _y <= max_y; _y++) {
    for (uint32_t _x = min_x; _x <= max_x; _x++) {
      if (_x == x && _y == y) {
        continue;
      }
      if (get(_x, _y) == to_count) {
        count++;
      }
    }
  }
  return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, %ebp
movl %esi, %r14d
movl %esi, %eax
subl %r8d, %eax
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %eax
movl %eax, 0x4(%rsp)
leal (%r8,%r14), %eax
movl (%rdi), %r15d
movq %rdi, 0x10(%rsp)
movl 0x4(%rdi), %ecx
decl %r15d
cmpl %eax, %r15d
cmovgel %eax, %r15d
movl %edx, %r13d
subl %r8d, %r13d
testl %r13d, %r13d
cmovlel %r12d, %r13d
addl %edx, %r8d
decl %ecx
cmpl %r8d, %ecx
cmovgel %r8d, %ecx
movl %ecx, 0x8(%rsp)
cmpl 0x8(%rsp), %r13d
ja 0x29d3
movl 0x4(%rsp), %ebx
cmpl %r15d, %ebx
ja 0x29ce
movl %r13d, %eax
xorl %ebp, %eax
movl %r14d, %ecx
xorl %ebx, %ecx
orl %eax, %ecx
je 0x29ca
movq 0x10(%rsp), %rdi
movl %ebx, %esi
movl %r13d, %edx
callq 0x290a
xorl %ecx, %ecx
cmpb 0xc(%rsp), %al
sete %cl
addl %ecx, %r12d
incl %ebx
jmp 0x299c
incl %r13d
jmp 0x2991
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsseW[P]bytepusher/src/grid/rules.cpp
// Function: game_of_life_rule(Grid&, unsigned int, unsigned int)
void game_of_life_rule(Grid& grid, uint32_t x, uint32_t y) {
  Tile tile = grid.get(x, y);
  uint32_t count = grid.count_neighbors(x, y);
  if (tile == Tile::Alive) {
    if (count < 2 || count > 3) {
      tile = Tile::Dead;
    }
  } else if (tile == Tile::Dead && count == 3) {
    tile = Tile::Alive;
  }
  grid.set(x, y, tile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x290a
movl %eax, %r15d
movl $0xff, %r12d
pushq $0x1
popq %r8
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
movl $0xff, %ecx
callq 0x2932
cmpb $-0x1, %r15b
je 0x2a4c
cmpl $0x3, %eax
movzbl %r15b, %eax
cmovnel %eax, %r12d
testb %r15b, %r15b
cmovnel %eax, %r12d
jmp 0x2a59
andl $-0x2, %eax
cmpl $0x2, %eax
sete %r12b
negb %r12b
movzbl %r12b, %ecx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2924
// File: /workspace/github_cpp_makefile_star2_O2/IsseW[P]bytepusher/src/grid/rules.cpp
// Function: water_sim_rule(Grid&, unsigned int, unsigned int)
void water_sim_rule(Grid& grid, uint32_t x, uint32_t y) {
  Tile tile = grid.get(x, y);
  if (tile == Tile::Alive) {
    if (grid.get(x, y + 1) == Tile::Dead) {
      tile = Tile::Dead;
      grid.set(x, y + 1, Tile::Alive);
    } else if (grid.get(x + 1, y) == Tile::Dead && grid.get(x + 1, y + 1) == Tile::Dead) {
      tile = Tile::Dead;
      grid.set(x + 1, y + 1, Tile::Alive);
    } else if (grid.get(x - 1, y) == Tile::Dead && grid.get(x - 1, y + 1) == Tile::Dead) {
      tile = Tile::Dead;
      grid.set(x - 1, y + 1, Tile::Alive);
    }
  }
  grid.set(x, y, tile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
callq 0x290a
movl %eax, %r13d
cmpb $-0x1, %al
jne 0x2b0b
leal 0x1(%rbx), %ebp
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x290a
movl %r14d, %r12d
testb %al, %al
je 0x2af6
leal 0x1(%r14), %r12d
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %edx
callq 0x290a
testb %al, %al
jne 0x2acd
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x290a
testb %al, %al
je 0x2af6
leal -0x1(%r14), %r12d
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %edx
callq 0x290a
movb $-0x1, %r13b
testb %al, %al
jne 0x2b0b
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x290a
testb %al, %al
jne 0x2b0b
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
movl $0xff, %ecx
callq 0x2924
xorl %r13d, %r13d
movzbl %r13b, %ecx
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2924
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsseW[P]bytepusher/src/renderer/renderer.cpp
// Function: Renderer::Renderer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int, unsigned int, unsigned int)
Renderer::Renderer(
    const std::string& name, 
    uint32_t bw, uint32_t bh,
    uint32_t ww, uint32_t wh
):  bw{bw}, bh{bh},
    ww{ww}, wh{wh} 
{
    init_backend();
    SDL_CreateWindowAndRenderer(ww, wh, 0, &sdl_win, &sdl_rend);
    sdl_text = SDL_CreateTexture(sdl_rend, SDL_PIXELFORMAT_RGB332, SDL_TEXTUREACCESS_TARGET, bw, bh);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r12d
movl %r8d, %r13d
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %rbx
movl %edx, (%rdi)
movl %ecx, 0x4(%rdi)
movl %r8d, 0x8(%rdi)
movl %r9d, 0xc(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
callq 0x2b2c
leaq 0x28(%rbx), %rcx
leaq 0x30(%rbx), %r14
movl %r13d, %edi
movl %r12d, %esi
xorl %edx, %edx
movq %r14, %r8
callq 0x2070
movq (%r14), %rdi
pushq $0x2
popq %rdx
movl $0x14110801, %esi       # imm = 0x14110801
movl %r15d, %ecx
movl %ebp, %r8d
callq 0x2220
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x2678
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsseW[P]bytepusher/src/renderer/renderer.cpp
// Function: Renderer::finalize()
void Renderer::finalize(){
    SDL_UnlockTexture(sdl_text);
    SDL_SetRenderDrawColor(sdl_rend, 0, 0, 0, 0);
    SDL_RenderClear(sdl_rend);
    SDL_RenderCopy(sdl_rend, sdl_text, nullptr, nullptr);
    SDL_RenderPresent(sdl_rend);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x21d0
movq 0x30(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x21e0
movq 0x30(%rbx), %rdi
callq 0x2170
movq 0x20(%rbx), %rsi
movq 0x30(%rbx), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2180
movq 0x30(%rbx), %rdi
popq %rbx
jmp 0x2050
nop
// File: /workspace/github_cpp_makefile_star2_O2/IsseW[P]bytepusher/src/renderer/renderer.cpp
// Function: Renderer::poll_events()
bool Renderer::poll_events(){
    SDL_Event event;
    while(SDL_PollEvent(&event)){
        if(meh)
            meh(event);
        switch(event.type){
        case SDL_QUIT:
            destroy();
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x20f0
movl %eax, %ebp
testl %eax, %eax
je 0x2ce3
cmpq $0x0, 0x48(%rbx)
je 0x2cd2
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d42
cmpl $0x100, (%rsp)          # imm = 0x100
jne 0x2cb2
movq %rbx, %rdi
callq 0x2c06
testl %ebp, %ebp
sete %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::setUp(unsigned int)
void TaskQueue::setUp(uint32_t max_capacity)
{
	this->tasks = new queue<Task*>();
	sem_init(&(this->lock),0,1);
	sem_init(&(this->unfinished_business),0,0);
	sem_init(&(this->space_available),0,max_capacity);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x50
popq %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
callq 0x3830
movq %r15, (%r14)
leaq 0x8(%r14), %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x2140
leaq 0x28(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2140
addq $0x48, %r14
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x2140
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r15, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::clear()
void TaskQueue::clear()
{
	sem_wait(&(this->lock));
	while (!this->tasks->empty())
	{
		delete this->tasks->front();
		this->tasks->pop();

		sem_wait(&(this->unfinished_business)); // this will never block (well, it shouldn't...if it does, that's a logic error)
		sem_post(&(this->space_available));
	}
	sem_post(&(this->lock));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x20c0
leaq 0x28(%r14), %r15
leaq 0x48(%r14), %r12
pushq $0x48
popq %r13
movq (%r14), %rcx
movq 0x10(%rcx), %rax
cmpq %rax, 0x30(%rcx)
je 0x34ac
movq (%rax), %rbp
testq %rbp, %rbp
je 0x3487
movq %rbp, %rdi
callq 0x3da8
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2190
movq (%r14), %rdi
callq 0x3cb6
movq %r15, %rdi
callq 0x20c0
movq %r12, %rdi
callq 0x2240
jmp 0x346a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::add(Task*)
void TaskQueue::add(Task* task)
{
	sem_wait(&(this->space_available));
	sem_wait(&(this->lock));
	this->tasks->push(task);
	sem_post(&(this->lock));
	sem_post(&(this->unfinished_business));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
addq $0x48, %rdi
callq 0x20c0
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x20c0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3aca
movq %r15, %rdi
callq 0x2240
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x2240
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::get()
Task* TaskQueue::get()
{
	sem_wait(&(this->unfinished_business));
	sem_wait(&(this->lock));
	Task* temp_ptr = this->tasks->front();
	this->tasks->pop();
	sem_post(&(this->lock));
	sem_post(&(this->space_available));
	return temp_ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x20c0
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x20c0
movq (%rbx), %rdi
movq 0x10(%rdi), %rax
movq (%rax), %r15
callq 0x3cb6
movq %r14, %rdi
callq 0x2240
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x2240
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop