LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::LineLineIntersectionPoint(PolyLine const&, vec&) const
bool PolyLine::LineLineIntersectionPoint(const PolyLine &line, PointType &pos) const
{
    auto &c = line.a;
    auto &d = line.b;
    
    // Line AB represented as a1x + b1y = c1
    double a1 = b.y - a.y;
    double b1 = a.x - b.x;
    double c1 = a1*(a.x) + b1*(a.y);
  
    // Line CD represented as a2x + b2y = c2
    double a2 = d.y - c.y;
    double b2 = c.x - d.x;
    double c2 = a2*(c.x)+ b2*(c.y);
  
    double determinant = a1*b2 - a2*b1;
  
    if (determinant == 0)
    {
        // The lines are parallel. This is simplified
        // by returning a pair of FLT_MAX
        return false;
    }

    double x = (b2*c1 - b1*c2)/determinant;
    double y = (a1*c2 - a2*c1)/determinant;
    pos = PointType(x, y, 0.0f);
    
    return true;
}

// Assembly:
movss 0x4(%rdi), %xmm0
movups (%rdi), %xmm2
movups 0x8(%rdi), %xmm1
movss (%rsi), %xmm6
movss 0x4(%rsi), %xmm3
movss 0xc(%rsi), %xmm4
movlhps %xmm2, %xmm4            # xmm4 = xmm4[0],xmm2[0]
shufps $0xe2, %xmm2, %xmm4     # xmm4 = xmm4[2,0],xmm2[2,3]
movaps %xmm3, %xmm5
movlhps %xmm1, %xmm5            # xmm5 = xmm5[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm5     # xmm5 = xmm5[2,0],xmm1[2,3]
subps %xmm5, %xmm4
cvtps2pd %xmm4, %xmm1
movups 0x8(%rsi), %xmm4
movss 0xc(%rdi), %xmm5
movaps %xmm6, %xmm7
unpcklps %xmm5, %xmm7            # xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1]
movaps %xmm0, %xmm5
movlhps %xmm4, %xmm5            # xmm5 = xmm5[0],xmm4[0]
shufps $0xe2, %xmm4, %xmm5     # xmm5 = xmm5[2,0],xmm4[2,3]
subps %xmm5, %xmm7
cvtps2pd %xmm7, %xmm5
movapd %xmm1, %xmm7
unpckhpd %xmm1, %xmm7            # xmm7 = xmm7[1],xmm1[1]
mulsd %xmm1, %xmm7
movapd %xmm5, %xmm4
unpckhpd %xmm5, %xmm4            # xmm4 = xmm4[1],xmm5[1]
mulsd %xmm5, %xmm4
subsd %xmm7, %xmm4
xorpd %xmm7, %xmm7
ucomisd %xmm7, %xmm4
jne 0x274e
jnp 0x279f
movlhps %xmm2, %xmm6            # xmm6 = xmm6[0],xmm2[0]
shufps $0xe2, %xmm2, %xmm6     # xmm6 = xmm6[2,0],xmm2[2,3]
cvtps2pd %xmm6, %xmm2
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
cvtps2pd %xmm0, %xmm0
movapd %xmm1, %xmm3
unpcklpd %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0]
mulpd %xmm0, %xmm3
movapd %xmm5, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
mulpd %xmm2, %xmm0
addpd %xmm3, %xmm0
mulpd %xmm0, %xmm5
shufpd $0x1, %xmm0, %xmm0      # xmm0 = xmm0[1,0]
mulpd %xmm1, %xmm0
subpd %xmm0, %xmm5
movapd %xmm4, %xmm0
unpcklpd %xmm4, %xmm0            # xmm0 = xmm0[0],xmm4[0]
divpd %xmm0, %xmm5
cvtpd2ps %xmm5, %xmm0
movlpd %xmm0, (%rdx)
cmpneqsd %xmm7, %xmm4
movq %xmm4, %rax
andl $0x1, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::iCompareLineOrder(PolyLine const&, PolyLine&)
static int iComparePointOrder(const PointType &p1, const PointType &p2)
{
    if (p1.y < p2.y)
        return -1;
    else if (p1.y == p2.y)
    {
        if (p1.x < p2.x)
            return -1;
        else if (p1.x == p2.x)
            return 0;
    }
    // p1 is greater than p2
    return 1;
}

// Assembly:
movss 0x4(%rdi), %xmm0
movss 0x4(%rsi), %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomiss %xmm0, %xmm1
ja 0x27f7
ucomiss %xmm1, %xmm0
jne 0x27f2
jp 0x27f2
movss (%rdi), %xmm2
movss (%rsi), %xmm3
xorl %ecx, %ecx
ucomiss %xmm2, %xmm3
ja 0x27f9
movb $0x1, %cl
ucomiss %xmm3, %xmm2
movl $0x0, %eax
jne 0x27f2
jnp 0x27f9
movl $0x1, %eax
xorl %ecx, %ecx
testb %cl, %cl
je 0x2840
movups (%rdi), %xmm5
movups 0x8(%rdi), %xmm6
movups 0xc(%rdi), %xmm4
movss (%rsi), %xmm7
movss 0x8(%rsi), %xmm2
movss 0xc(%rsi), %xmm3
movlhps %xmm6, %xmm2            # xmm2 = xmm2[0],xmm6[0]
shufps $0xe2, %xmm6, %xmm2     # xmm2 = xmm2[2,0],xmm6[2,3]
movlhps %xmm5, %xmm7            # xmm7 = xmm7[0],xmm5[0]
shufps $0xe2, %xmm5, %xmm7     # xmm7 = xmm7[2,0],xmm5[2,3]
subps %xmm7, %xmm2
movaps %xmm2, %xmm5
shufps $0x55, %xmm2, %xmm5     # xmm5 = xmm5[1,1],xmm2[1,1]
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm2
movl $0x1, %eax
jbe 0x2841
ucomiss %xmm5, %xmm6
jbe 0x2841
retq
ucomiss %xmm2, %xmm6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jbe 0x2850
ucomiss %xmm6, %xmm5
ja 0x2840
ucomiss %xmm6, %xmm2
jne 0x2868
jp 0x2868
ucomiss %xmm6, %xmm5
ja 0x2840
xorps %xmm0, %xmm0
xorl %eax, %eax
ucomiss %xmm5, %xmm0
seta %al
retq
ucomiss %xmm6, %xmm5
jne 0x2887
jp 0x2887
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm2
movl $0x1, %eax
ja 0x2840
xorl %eax, %eax
ucomiss %xmm2, %xmm0
seta %al
negl %eax
retq
movlhps %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
shufps $0xe2, %xmm4, %xmm3     # xmm3 = xmm3[2,0],xmm4[2,3]
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subps %xmm0, %xmm3
divps %xmm2, %xmm3
movaps %xmm3, %xmm0
shufps $0x55, %xmm3, %xmm0     # xmm0 = xmm0[1,1],xmm3[1,1]
xorl %ecx, %ecx
ucomiss %xmm3, %xmm0
seta %cl
ucomiss %xmm0, %xmm3
cmovbel %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::HasCommonIdxPoints(PolyLine const&) const
bool PolyLine::HasCommonIdxPoints(const PolyLine &line) const
{
    return
        aIdx == line.aIdx ||
        aIdx == line.bIdx ||
        bIdx == line.aIdx ||
        bIdx == line.bIdx;
}

// Assembly:
movl 0x80(%rdi), %r8d
movl 0x80(%rsi), %ecx
movb $0x1, %al
cmpl %ecx, %r8d
je 0x28df
movl 0x84(%rsi), %edx
cmpl %edx, %r8d
je 0x28df
movl 0x84(%rdi), %eax
cmpl %ecx, %eax
sete %cl
cmpl %edx, %eax
sete %al
orb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyDetector::newLine(unsigned int, unsigned int, PolyLine&)
PolyLine PolyDetector::newLine(uint32_t i, uint32_t j, PolyLine &origLine)
{
    PolyLine l;
    
    l.aIdx = origLine.intersections[i];
    l.bIdx = origLine.intersections[j];
    l.a = intersectionPoints[l.aIdx];
    l.b = intersectionPoints[l.bIdx];
    l.origLine = origLine.id;
    l.lastDissolveStep = origLine.lastDissolveStep;
    l.attr0 = origLine.attr0;
    l.calcCenter();
    
    return l;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
addq $0x30, %rdi
movl %eax, 0x30(%rbx)
movq %rax, 0x38(%rbx)
movq %rdi, 0x40(%rbx)
movq %rdi, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movaps 0xd661(%rip), %xmm1     # 0x10010
movups %xmm1, 0x60(%rbx)
movl $0xffffffff, 0x70(%rbx) # imm = 0xFFFFFFFF
movb $0x0, 0x74(%rbx)
movups %xmm0, 0x78(%rbx)
movl %eax, 0x88(%rbx)
movl %edx, %eax
movq 0x10(%r8), %rdx
movl (%rdx,%rax,4), %eax
movl %eax, 0x80(%rbx)
movl %ecx, %ecx
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x84(%rbx)
movq 0xc8(%rsi), %rdx
movq (%rdx,%rax,8), %rax
movq %rax, (%rbx)
movq (%rdx,%rcx,8), %rax
movq %rax, 0x8(%rbx)
movl 0x60(%r8), %eax
movl %eax, 0x6c(%rbx)
movl 0x88(%r8), %eax
movl %eax, 0x88(%rbx)
movl 0x70(%r8), %eax
movl %eax, 0x70(%rbx)
movq %rbx, %rdi
callq 0x53b6
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
addps %xmm0, %xmm1
mulps 0xd5f2(%rip), %xmm1     # 0x10020
movlps %xmm1, 0x58(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyDetector::addPointToLine(unsigned int, unsigned int)
bool PolyDetector::addPointToLine(uint32_t pid, uint32_t lid)
{
    auto &v = pointToLines[pid];
    if (std::find(v.begin(), v.end(), lid) == v.end())
    {
        v.push_back(lid);
        return true;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
leaq 0x8(%rsp), %r14
movl %edx, (%r14)
addq $0xe0, %rdi
movq %rax, %rsi
callq 0xb3c8
movq %rax, %rbx
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r14, %rdx
callq 0xc8a4
movq %rax, %r14
movq 0x8(%rbx), %r15
cmpq %r15, %rax
jne 0x53a6
cmpq 0x10(%rbx), %r15
je 0x5396
movl 0x8(%rsp), %eax
movl %eax, (%r15)
leaq 0x4(%r15), %rax
movq %rax, 0x8(%rbx)
jmp 0x53a6
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc93e
cmpq %r15, %r14
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyDetector::SortLines()
void PolyDetector::SortLines(void)
{
    for (auto &line : lines)
    {
        if (!line.ignore)
            line.CalculateFirstAndLastPoint();
    }
    std::sort(lines.begin(), lines.end(), PolyLine::bCompareLineOrder);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rbx
movq 0x38(%rdi), %r15
cmpq %r15, %rbx
je 0x5430
cmpb $0x0, 0x74(%rbx)
jne 0x5427
movq %rbx, %rdi
callq 0x53b6
addq $0x90, %rbx
jmp 0x5414
movq 0x30(%r14), %rbx
movq 0x38(%r14), %r14
cmpq %r14, %rbx
je 0x548a
movq %r14, %rax
subq %rbx, %rax
sarq $0x4, %rax
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0x2cbb(%rip), %r15     # 0x27ae
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xcac8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xcc41
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %edx, %ecx
movl %esi, %eax
movq 0x110(%rdi), %r9
movq 0x118(%rdi), %r10
xorl %ebx, %ebx
xorl %edx, %edx
divq %r10
movq (%r9,%rdx,8), %rax
testq %rax, %rax
je 0x5768
movq (%rax), %r11
movq %rax, %rbx
cmpl %esi, 0x8(%r11)
je 0x5768
movq %rdx, %r8
movq %r11, %r14
movq (%r11), %r11
testq %r11, %r11
je 0x5766
movl 0x8(%r11), %r9d
movq %r9, %rax
xorl %edx, %edx
divq %r10
movl $0x0, %ebx
cmpq %r8, %rdx
jne 0x5768
movq %r14, %rbx
cmpl %esi, %r9d
jne 0x573b
jmp 0x5768
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x5772
movq (%rbx), %rax
jmp 0x5774
xorl %eax, %eax
testq %rax, %rax
je 0x5797
movslq 0xc(%rax), %rax
leaq (%rax,%rax,8), %rbx
shlq $0x4, %rbx
addq 0x30(%rdi), %rbx
testb %cl, %cl
je 0x57c5
cmpb $0x0, 0x74(%rbx)
je 0x57c5
xorl %ebx, %ebx
jmp 0x57c5
movl 0x128(%rdi), %edx
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
shrq $0x4, %rax
imull $0x38e38e39, %eax, %ecx # imm = 0x38E38E39
leaq 0xb104(%rip), %rdi      # 0x108ba
xorl %ebx, %ebx
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
xorl %eax, %eax
callq 0x2030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %rbx
movq 0x78(%rsi), %rdx
leaq 0x70(%rsi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x5808
movl 0x60(%rdi), %esi
movq %rax, %rcx
xorl %r8d, %r8d
cmpl %esi, 0x20(%rdx)
setb %r8b
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%r8,8), %rdx
testq %rdx, %rdx
jne 0x57f0
movq %rax, %rdx
cmpq %rax, %rcx
je 0x581d
movl 0x60(%rdi), %edx
cmpl 0x20(%rcx), %edx
cmovbq %rax, %rcx
movq %rcx, %rdx
xorl %ebp, %ebp
cmpq %rax, %rdx
je 0x5853
movq 0x28(%rdx), %r14
movq 0x30(%rdx), %r15
cmpq %r15, %r14
je 0x5853
xorl %ebp, %ebp
movl (%r14), %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x5706
cmpq $0x1, %rax
sbbl $-0x1, %ebp
addq $0x4, %r14
cmpq %r15, %r14
jne 0x5833
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x80(%rdi), %eax
movl 0x80(%rdx), %ecx
movl %eax, %ebp
cmpl %ecx, %eax
je 0x7591
movl 0x84(%r14), %edx
movl %eax, %ebp
cmpl %edx, %eax
je 0x7591
movl 0x84(%r15), %esi
cmpl %edx, %esi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmovel %esi, %ebp
cmpl %ecx, %esi
cmovel %esi, %ebp
testl %ebp, %ebp
js 0x7631
movl 0x80(%rbx), %ecx
movl %eax, %edx
cmpl %ecx, %eax
je 0x75c7
movl 0x84(%rbx), %esi
movl %eax, %edx
cmpl %esi, %eax
je 0x75c7
movl 0x84(%r15), %edi
cmpl %esi, %edi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmovel %edi, %edx
cmpl %ecx, %edi
cmovel %edi, %edx
cmpl %edx, %ebp
jne 0x7631
movl %ebp, %ecx
movq 0xc8(%r12), %rdx
movq (%rdx,%rcx,8), %rcx
leaq 0x10(%rsp), %rdi
movq %rcx, (%rdi)
cmpl %ebp, %eax
cmovel 0x84(%r15), %eax
movq (%rdx,%rax,8), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x58(%r14), %rdx
leaq 0x58(%rbx), %rcx
callq 0x2501
movl %eax, %r13d
testb %al, %al
je 0x7634
cmpl $0x3, 0x60(%r12)
jb 0x7634
movl 0x60(%r15), %esi
movl 0x60(%r14), %edx
movl 0x60(%rbx), %ecx
leaq 0x9475(%rip), %rdi      # 0x10a9a
movl %ebp, %r8d
xorl %eax, %eax
callq 0x2030
jmp 0x7634
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
movl $0x1, %edx
callq 0x5706
movq %rax, %r14
movq %r15, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x5706
testq %r14, %r14
je 0x7faf
testq %rax, %rax
je 0x7faf
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
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8b11(%rip), %rdi      # 0x10ac7
leaq 0x8173(%rip), %rsi      # 0x10130
leaq 0x8b09(%rip), %rcx      # 0x10acd
movl $0x7a0, %edx            # imm = 0x7A0
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb3c8
movq (%rax), %r12
movq 0x8(%rax), %r15
cmpq %r15, %r12
je 0x8067
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 0x98c9
cmpq $0x41, %r13
jl 0x8056
leaq 0x40(%r12), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x9c66
cmpq %r15, %r13
je 0x8067
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9d08
addq $0x4, %r13
jmp 0x803d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x9c66
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyPol::addPointChecked(vec const&)
bool PolyPol::addPointChecked(const PointType &v)
{
    for (auto &pt : p)
        if (!pointsDiffer(pt, v))
            return false;
    p.push_back(v);
    return true;
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
cmpq %rsi, %rax
sete %bl
je 0x83c4
movss (%rdx), %xmm0
movss 0x4(%rdx), %xmm1
movss (%rax), %xmm2
movss 0x4(%rax), %xmm3
subss %xmm0, %xmm2
subss %xmm1, %xmm3
mulss %xmm3, %xmm3
mulss %xmm2, %xmm2
addss %xmm3, %xmm2
ucomiss 0x7cfc(%rip), %xmm2     # 0x10080
jb 0x83c0
addq $0x8, %rax
movss 0x7cee(%rip), %xmm2     # 0x10080
cmpq %rsi, %rax
sete %bl
je 0x83c4
movss (%rax), %xmm3
movss 0x4(%rax), %xmm4
subss %xmm0, %xmm3
subss %xmm1, %xmm4
mulss %xmm4, %xmm4
mulss %xmm3, %xmm3
addss %xmm4, %xmm3
addq $0x8, %rax
ucomiss %xmm2, %xmm3
jae 0x8392
testb %bl, %bl
je 0x83dc
cmpq 0x10(%rdi), %rsi
je 0x83d7
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x83dc
callq 0xdf38
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8b67
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
cmpl $0x0, 0x60(%rsi)
je 0x8b5a
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4d08
movq (%r15), %rdx
leaq 0x831a(%rip), %rdi      # 0x10e58
movq %r14, %rsi
xorl %eax, %eax
callq 0x2030
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x8b5a
callq 0x2140
movb $0x1, 0x74(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x10(%rsp)
movl %eax, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movl 0x20(%rsp,%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0xb3c8
movq (%rax), %r15
movq 0x8(%rax), %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x8c03
movl (%r15), %esi
cmpl 0x60(%rbx), %esi
je 0x8bf2
movq %r14, %rdi
movl $0x1, %edx
callq 0x5706
testq %rax, %rax
je 0x8bf2
movl 0x78(%rax), %ecx
cmpl $0x2, %ecx
adcl $0x0, %r13d
cmpl $0x2, %ecx
cmovbq %rax, %rbp
addq $0x4, %r15
cmpq %r12, %r15
jne 0x8bc7
cmpl $0x1, %r13d
sete %r13b
movb $0x1, %r15b
testb %r13b, %r13b
je 0x8c77
movl 0x60(%rbx), %esi
movl 0x60(%rbp), %edx
movq %r14, %rdi
callq 0x8f3a
testb %al, %al
je 0x8c77
cmpl $0x0, 0x60(%r14)
je 0x8c62
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4d08
movq 0x28(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x60(%rbp), %ecx
leaq 0x811c(%rip), %rdi      # 0x10d63
xorl %eax, %eax
callq 0x2030
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x8c62
callq 0x2140
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x853e
movl %eax, 0x8(%rsp)
xorl %r15d, %r15d
testb %r15b, %r15b
je 0x8c93
movq 0x18(%rsp), %rax
addq $0x4, %rax
cmpq $0x8, %rax
jne 0x8b9a
xorl %eax, %eax
jmp 0x8c97
movl 0x8(%rsp), %eax
andb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movl %edx, 0xc(%rsp)
movq 0xa8(%rdi), %rcx
addq $0xa0, %rdi
movq %rdi, %rax
testq %rcx, %rcx
je 0x8f72
movq %rdi, %rax
xorl %edx, %edx
cmpl %esi, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x8f5c
movq %rdi, %rbx
cmpq %rdi, %rax
je 0x8f84
cmpl %esi, 0x20(%rax)
cmovaq %rdi, %rax
movq %rax, %rbx
cmpq %rdi, %rbx
je 0x8fa4
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
leaq 0xc(%rsp), %rdx
callq 0xc8a4
cmpq 0x30(%rbx), %rax
setne %al
jmp 0x8fa6
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %eax, %eax
movq %rax, 0x20(%rsp)
leaq 0x50(%rsp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movq (%rdi), %r14
movq 0x8(%rdi), %rax
movq %rax, 0x38(%rsp)
cmpq %rax, %r14
je 0x921a
leaq 0x8(%rsp), %r12
leaq 0x7d1b(%rip), %r13      # 0x10e6d
movq 0x18(%r14), %rbp
leaq 0x8(%r14), %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %rbp
je 0x920b
movl 0x20(%rbp), %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x5706
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x91f5
movq 0x80(%rax), %rax
movq %rax, 0x30(%rsp)
xorl %r15d, %r15d
movl 0x30(%rsp,%r15), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8fac
testb %al, %al
je 0x91eb
cmpl $0x0, 0x60(%rbx)
je 0x91c2
movl 0x30(%rsp,%r15), %esi
movq 0x8(%rsp), %rax
movl 0x60(%rax), %edx
movq %r13, %rdi
xorl %eax, %eax
callq 0x2030
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x91de
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%rsp)
jmp 0x91eb
leaq 0x10(%rsp), %rdi
movq %r12, %rdx
callq 0xedac
addq $0x4, %r15
cmpq $0x8, %r15
jne 0x9191
movq %rbp, %rdi
callq 0x2180
movq %rax, %rbp
cmpq 0x40(%rsp), %rax
jne 0x9168
addq $0x40, %r14
cmpq 0x38(%rsp), %r14
jne 0x9152
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r12
cmpq %r12, %r15
je 0x9247
leaq 0x7c67(%rip), %r14      # 0x10e97
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x8b08
addq $0x8, %r15
cmpq %r12, %r15
jne 0x9230
leaq 0x48(%rsp), %rdi
callq 0xc16e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9260
callq 0x2140
movb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9273
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xc16e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x928f
callq 0x2140
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r15, %r12
je 0x92c7
movq %r15, %r14
movq %r14, %rdi
callq 0xc16e
addq $0x40, %r14
cmpq %r12, %r14
jne 0x92b2
movq %r15, 0x8(%rbx)
leaq 0x18(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0xc182
leaq 0x30(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0xc182
leaq 0x48(%rbx), %rdi
movq 0x48(%rbx), %rsi
callq 0xe288
leaq 0x68(%rbx), %rdi
callq 0xca56
leaq 0x98(%rbx), %rdi
callq 0xca56
movq 0xc8(%rbx), %rax
cmpq %rax, 0xd0(%rbx)
je 0x931a
movq %rax, 0xd0(%rbx)
leaq 0xe0(%rbx), %rdi
callq 0xca56
movl $0x0, 0x148(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x938d
ucomiss %xmm2, %xmm1
movq %rdi, %rax
cmovaq %rdx, %rax
ucomiss (%rax), %xmm0
jb 0x938d
movss 0x4(%rsi), %xmm0
movss 0x4(%rdi), %xmm1
movss 0x4(%rdx), %xmm2
movaps %xmm2, %xmm3
maxss %xmm1, %xmm3
ucomiss %xmm0, %xmm3
jb 0x938d
ucomiss %xmm2, %xmm1
cmovaq %rdx, %rdi
movb $0x1, %al
ucomiss 0x4(%rdi), %xmm0
jae 0x938f
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rdi, %rbp
leaq 0x10(%rdi), %rax
movq %rax, 0x48(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x18(%rsi), %r15
addq $0x8, %rsi
movq %rsi, 0x50(%rsp)
cmpq %rsi, %r15
je 0xb5c2
leaq 0x8(%rsp), %r13
movl $0xd1b71759, %ebx       # imm = 0xD1B71759
movq %rbp, %r12
movl 0x20(%r15), %ebp
movl $0x1, %eax
cmpl $0xa, %ebp
jb 0xb4f1
movl $0x4, %eax
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0xb4ea
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0xb4ef
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0xb4f1
movl %ecx, %edx
imulq %rbx, %rdx
shrq $0x2d, %rdx
addl $0x4, %eax
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0xb4b9
addl $-0x3, %eax
jmp 0xb4f1
addl $-0x2, %eax
jmp 0xb4f1
decl %eax
movl %eax, %esi
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rdi
xorl %edx, %edx
callq 0x2190
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movl %ebp, %edx
callq 0xbea5
movq %r13, %r14
movq %r13, %rdi
leaq 0x5550(%rip), %rsi      # 0x10a74
callq 0x2230
leaq 0x38(%rsp), %r13
movq %r13, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movq %r12, %rbp
je 0xb554
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0xb55c
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbp, %rdi
callq 0x2060
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xb595
callq 0x2140
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb5a9
callq 0x2140
movq %r15, %rdi
callq 0x2180
movq %rax, %r15
cmpq 0x50(%rsp), %rax
movq %r14, %r13
jne 0xb4a1
cmpq $0x0, 0x8(%rbp)
je 0xb5d1
movq %rbp, %rdi
callq 0x21a0
movq %rbp, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xb613
movq %rax, %r14
jmp 0xb5ff
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xb5ff
callq 0x2140
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb613
callq 0x2140
movq (%r12), %rdi
cmpq 0x48(%rsp), %rdi
je 0xb623
callq 0x2140
movq %r14, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x387c
xorl %r15d, %r15d
jmp 0x3963
movl %edx, %ebx
xorl %r15d, %r15d
cmpl $0x8, %edx
jg 0x3963
movl %esi, %r14d
leal 0x7fffffff(%r14), %eax
andl %esi, %eax
jne 0x3963
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 0x3963
movl %edi, %ebp
movl %r14d, %edi
callq 0x411a
movl %eax, %r15d
movl %eax, 0xc(%rsp)
movl $0x30, %edi
callq 0x3240
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %r15d, %ecx
shll %cl, %r13d
movl %ebx, %ecx
shll %cl, %r12d
movq %rax, %r15
notl %r13d
notl %r12d
movl %r14d, %edi
movl $0x1, %esi
callq 0x3110
movq %rax, 0x10(%rsp)
movl $0x7, %edi
movl $0x8, %esi
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_O1/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:
movl (%rdi), %eax
cmpl 0xc(%rdi), %eax
jl 0x3af5
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movl %ebp, %eax
sarl $0x3, %eax
cltq
movl (%rbx,%rax), %eax
movl %ebp, %ecx
andb $0x7, %cl
shrl %cl, %eax
andl 0x10(%r14), %eax
cltq
movslq 0x4(%r14), %r12
decq %r12
andq %rax, %r12
movq 0x18(%r14), %rax
movzbl (%rax,%r12), %ecx
cmpl %ecx, 0x14(%r14)
jle 0x39f3
incb %cl
movb %cl, (%rax,%r12)
jmp 0x3ad4
movl 0x20(%r14), %r13d
movl 0x24(%r14), %eax
leal (%rax,%rax,4), %ecx
leal (%rax,%rax,4), %eax
addl $0x3, %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x2, %eax
cmpl %eax, %r13d
jg 0x3a89
movq 0x28(%r14), %r15
leal 0x1(,%r13,2), %eax
movl %eax, 0x20(%r14)
movslq %eax, %rdi
movl $0x8, %esi
callq 0x3110
movq %rax, 0x28(%r14)
testl %r13d, %r13d
js 0x3a81
movq 0x28(%r14), %rax
movl (%r15,%r13,8), %edx
movl 0x20(%r14), %esi
movl %esi, %ecx
andl %edx, %ecx
movslq %ecx, %rdi
cmpl $0x0, 0x4(%rax,%rdi,8)
je 0x3a6a
leaq (%rax,%rdi,8), %rdi
cmpl %edx, (%rdi)
je 0x3a6a
incl %ecx
andl %esi, %ecx
movslq %ecx, %rdi
leaq (%rax,%rdi,8), %rdi
cmpl $0x0, 0x4(%rdi)
jne 0x3a55
movslq %ecx, %rcx
movq (%r15,%r13,8), %rdx
movq %rdx, (%rax,%rcx,8)
leaq -0x1(%r13), %rax
testq %r13, %r13
movq %rax, %r13
jg 0x3a37
movq %r15, %rdi
callq 0x3210
movl 0x20(%r14), %edx
movq 0x28(%r14), %rax
movl %edx, %ecx
andl %r12d, %ecx
movslq %ecx, %rsi
cmpl $0x0, 0x4(%rax,%rsi,8)
je 0x3aba
leaq (%rax,%rsi,8), %rsi
cmpl %r12d, (%rsi)
je 0x3aba
incl %ecx
andl %edx, %ecx
movslq %ecx, %rsi
leaq (%rax,%rsi,8), %rsi
cmpl $0x0, 0x4(%rsi)
jne 0x3aa4
movslq %ecx, %rcx
movl 0x4(%rax,%rcx,8), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x4(%rax,%rcx,8)
testl %edx, %edx
jne 0x3ad4
movl %r12d, (%rax,%rcx,8)
incl 0x24(%r14)
movl (%r14), %eax
movl 0xc(%r14), %ecx
addl %ecx, %ebp
subl %ecx, %eax
cmpl %eax, %ebp
jle 0x39b8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rdi), %eax
cmpl 0xc(%rdi), %eax
jl 0x3c2c
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
movl %eax, %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movl (%rsi,%rcx), %edx
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %edx
andl 0x10(%rdi), %edx
movslq %edx, %rdx
movslq 0x4(%rdi), %rcx
decq %rcx
andq %rdx, %rcx
movq 0x18(%rdi), %rdx
movzbl (%rdx,%rcx), %edx
cmpl %edx, 0x14(%rdi)
jg 0x3c0e
movl 0x20(%rdi), %r9d
movq 0x28(%rdi), %r8
movl %r9d, %edx
andl %ecx, %edx
movslq %edx, %r10
cmpl $0x0, 0x4(%r8,%r10,8)
je 0x3b70
leaq (%r8,%r10,8), %r10
cmpl %ecx, (%r10)
je 0x3b70
incl %edx
andl %r9d, %edx
movslq %edx, %r10
leaq (%r8,%r10,8), %r10
cmpl $0x0, 0x4(%r10)
jne 0x3b58
movslq %edx, %r11
movl 0x4(%r8,%r11,8), %r10d
testl %r10d, %r10d
je 0x3c0e
movl %r10d, %ebx
decl %ebx
movl %ebx, 0x4(%r8,%r11,8)
jne 0x3c09
decl 0x24(%rdi)
incl %edx
andl %r9d, %edx
movslq %edx, %r11
cmpl $0x0, 0x4(%r8,%r11,8)
je 0x3c09
leaq (%r8,%r11,8), %rbx
movl (%rbx), %r14d
movl %r14d, %ebp
andl %r9d, %ebp
movslq %ebp, %r15
cmpl $0x0, 0x4(%r8,%r15,8)
je 0x3bd4
leaq (%r8,%r15,8), %r15
cmpl %r14d, (%r15)
je 0x3bd4
incl %ebp
andl %r9d, %ebp
movslq %ebp, %r15
leaq (%r8,%r15,8), %r15
cmpl $0x0, 0x4(%r15)
jne 0x3bbc
cmpl %edx, %ebp
je 0x3bef
movslq %ebp, %r9
movq (%rbx), %rbx
movq %rbx, (%r8,%r9,8)
movq 0x28(%rdi), %r8
movl $0x0, 0x4(%r8,%r11,8)
movq 0x28(%rdi), %r8
incl %edx
movl 0x20(%rdi), %r9d
andl %r9d, %edx
movslq %edx, %r11
leaq (%r8,%r11,8), %rbx
cmpl $0x0, 0x4(%rbx)
jne 0x3ba4
testl %r10d, %r10d
jne 0x3c15
movq 0x18(%rdi), %rdx
decb (%rdx,%rcx)
movl (%rdi), %ecx
movl 0xc(%rdi), %edx
addl %edx, %eax
subl %edx, %ecx
cmpl %ecx, %eax
jle 0x3b09
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rdi), %edx
movl 0xc(%rdi), %r8d
subl %r8d, %edx
movl $0x1, %eax
js 0x3c7c
movslq 0x10(%rdi), %rcx
movslq 0x4(%rdi), %r9
decq %r9
andq %rcx, %r9
movq 0x18(%rdi), %rdi
xorl %r10d, %r10d
movl %r10d, %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movl (%rsi,%rcx), %r11d
movl %r10d, %ecx
andb $0x7, %cl
shrl %cl, %r11d
movslq %r11d, %rcx
andq %r9, %rcx
cmpb $0x0, (%rdi,%rcx)
je 0x3c7d
addl %r8d, %r10d
cmpl %edx, %r10d
jle 0x3c52
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23fd(%rip), %rsi      # 0x6100
movq %rbx, %rdi
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r11
pushq %r10
callq 0x3280
addq $0x20, %rsp
cmpl $0x0, 0x4(%r14)
jle 0x3dbb
leaq 0x245b(%rip), %r13      # 0x6186
leaq 0x2446(%rip), %r15      # 0x6178
leaq 0x244a(%rip), %rbp      # 0x6183
xorl %r12d, %r12d
movq 0x18(%r14), %rax
movzbl (%rax,%r12), %r8d
testl %r8d, %r8d
je 0x3daf
movq %r13, %rdx
testq %r12, %r12
je 0x3d67
imull $0xcccccccd, %r12d, %eax # imm = 0xCCCCCCCD
rorl %eax
cmpl $0x1999999a, %eax       # imm = 0x1999999A
movq %r13, %rdx
cmovbq %rbp, %rdx
movq 0x28(%r14), %rax
movl 0x20(%r14), %esi
movl %r12d, %ecx
andl %esi, %ecx
cmpl $0x0, 0x4(%rax,%rcx,8)
je 0x3d97
leaq (%rax,%rcx,8), %rdi
movl (%rdi), %edi
cmpq %rdi, %r12
je 0x3d97
incl %ecx
andl %esi, %ecx
movslq %ecx, %rdi
leaq (%rax,%rdi,8), %rdi
cmpl $0x0, 0x4(%rdi)
jne 0x3d7f
movslq %ecx, %rcx
addl 0x4(%rax,%rcx,8), %r8d
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x3280
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0x3d3c
leaq 0x23c5(%rip), %rdi      # 0x6187
movq %rbx, %rsi
callq 0x31e0
cmpl $0x0, 0x20(%r14)
js 0x3e0a
movq $-0x1, %r12
leaq 0x23b3(%rip), %r15      # 0x6192
movq 0x28(%r14), %rax
movl 0xc(%rax,%r12,8), %ecx
testl %ecx, %ecx
je 0x3dfe
movl 0x8(%rax,%r12,8), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3280
movslq 0x20(%r14), %rax
incq %r12
cmpq %rax, %r12
jl 0x3ddf
leaq 0x2388(%rip), %rdi      # 0x6199
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl %edi, %r14d
xorl %r15d, %r15d
testl %edi, %edi
cmovlel %r15d, %r14d
cmpl %r15d, %r14d
je 0x12b7
movq (%rbx,%r15,8), %rdi
callq 0x10a0
incq %r15
cmpl $0x3, %r15d
jne 0x123a
movl $0x20, %edi
callq 0x1030
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xd96(%rip), %rsi       # 0x2004
leaq 0xda3(%rip), %rdx       # 0x2018
leaq -0x40(%rbp), %rdi
callq 0x13b8
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
movb $0x1, %r15b
movq %rbx, %rdi
callq 0x131e
xorl %r15d, %r15d
leaq 0x2b08(%rip), %rsi      # 0x3db0
leaq 0x4d(%rip), %rdx        # 0x12fc
movq %rbx, %rdi
callq 0x10b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x12e6
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x1080
jmp 0x12e6
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x12f3
movq %rbx, %rdi
callq 0x1050
movq %r14, %rdi
callq 0x10c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/eecs280staff[P]unit_test_framework/test/size_t_and_int.cpp
// Function: GLOBAL__sub_I_size_t_and_int.cpp
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 %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x5e69(%rip), %rbx      # 0x81d8
movq %rbx, %rdi
callq 0x2290
movq 0x5c7a(%rip), %rdi      # 0x7ff8
leaq 0x5e23(%rip), %rdx      # 0x81a8
movq %rbx, %rsi
callq 0x21b0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movabsq $0x615f745f657a6973, %rax # imm = 0x615F745F657A6973
movq %rax, (%r14)
movabsq $0x746e695f646e615f, %rax # imm = 0x746E695F646E615F
movq %rax, 0x6(%r14)
movq $0xe, -0x8(%r14)
movb $0x0, 0xe(%r14)
callq 0x261c
leaq 0x162(%rip), %rdx       # 0x252c
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2b8a
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x23ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x76f(%rip), %rdi       # 0x2b64
leaq 0x5ddd(%rip), %rsi      # 0x81d9
leaq 0x5da5(%rip), %rdx      # 0x81a8
callq 0x21b0
callq 0x261c
movq %rax, 0x5dcc(%rip)      # 0x81e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2436
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
je 0x288f
movq %rsi, %r14
xorl %ebp, %ebp
cmpl $0x0, (%rbx)
je 0x2888
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq *%r14
incl %r15d
cmpl (%rbx), %r15d
jb 0x2875
incl %ebp
cmpl 0x4(%rbx), %ebp
jb 0x286d
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x4(%rdi)
je 0x2977
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0x26ed(%rip), %r14      # 0x4fd8
movl $0x23, %r12d
leaq 0x7(%rsp), %r15
movl (%rbx), %eax
testl %eax, %eax
je 0x293b
xorl %r13d, %r13d
movb $0x2e, %cl
cmpl %ebp, 0x4(%rbx)
jbe 0x291d
movq 0x8(%rbx), %rcx
imull %ebp, %eax
addl %r13d, %eax
cmpb $-0x1, (%rcx,%rax)
movl $0x2e, %ecx
cmovel %r12d, %ecx
movb %cl, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
incl %r13d
movl (%rbx), %eax
cmpl %eax, %r13d
jb 0x28ff
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
incl %ebp
cmpl 0x4(%rbx), %ebp
jb 0x28f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %r9d
subl %r8d, %r9d
xorl %eax, %eax
testl %r9d, %r9d
cmovlel %eax, %r9d
leal (%r8,%rsi), %r10d
movl (%rdi), %r11d
leal -0x1(%r11), %ebx
cmpl %r10d, %ebx
cmovll %ebx, %r10d
movl 0x4(%rdi), %ebx
movl %edx, %ebp
subl %r8d, %ebp
testl %ebp, %ebp
cmovlel %eax, %ebp
addl %edx, %r8d
leal -0x1(%rbx), %r14d
cmpl %r8d, %r14d
cmovll %r14d, %r8d
cmpl %r8d, %ebp
ja 0x2a4f
movq 0x8(%rdi), %rdi
movl %r11d, %r14d
imull %ebp, %r14d
xorl %eax, %eax
movl %r9d, %r15d
cmpl %r10d, %r9d
ja 0x2a45
movl %ebp, %r12d
xorl %edx, %r12d
movl %esi, %r13d
xorl %r15d, %r13d
orl %r12d, %r13d
je 0x2a3d
cmpl %ebp, %ebx
setbe %r12b
cmpl %r15d, %r11d
setbe %r13b
orb %r12b, %r13b
jne 0x2a2d
leal (%r14,%r15), %r12d
movb (%rdi,%r12), %r12b
jmp 0x2a30
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpb %cl, %r12b
sete %r13b
addl %r13d, %eax
incl %r15d
cmpl %r10d, %r15d
jbe 0x2a00
incl %ebp
addl %r11d, %r14d
cmpl %r8d, %ebp
jbe 0x29f8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq