LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: iComparePointOrder(vec const&, vec const&)
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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movss 0x4(%rax), %xmm1
movq -0x18(%rsp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2c7d
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2ce2
movq -0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rsp), %rax
ucomiss 0x4(%rax), %xmm0
jne 0x2cd8
jp 0x2cd8
movq -0x10(%rsp), %rax
movss (%rax), %xmm1
movq -0x18(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2cb5
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2ce2
movq -0x10(%rsp), %rax
movss (%rax), %xmm0
movq -0x18(%rsp), %rax
ucomiss (%rax), %xmm0
jne 0x2cd4
jp 0x2cd4
movl $0x0, -0x4(%rsp)
jmp 0x2ce2
jmp 0x2cd6
jmp 0x2cd8
jmp 0x2cda
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl 0x80(%rax), %ecx
movq -0x10(%rsp), %rdx
movb $0x1, %al
cmpl 0x80(%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x2d76
movq -0x20(%rsp), %rax
movl 0x80(%rax), %ecx
movq -0x10(%rsp), %rdx
movb $0x1, %al
cmpl 0x84(%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x2d76
movq -0x20(%rsp), %rax
movl 0x84(%rax), %ecx
movq -0x10(%rsp), %rdx
movb $0x1, %al
cmpl 0x80(%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x2d76
movq -0x20(%rsp), %rax
movl 0x84(%rax), %eax
movq -0x10(%rsp), %rcx
cmpl 0x84(%rcx), %eax
sete %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x12910
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
movl 0x44(%rsp), %eax
movl %eax, %esi
callq 0x12a00
movq 0x18(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x80(%rdi)
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
movl 0x40(%rsp), %eax
movl %eax, %esi
callq 0x12a00
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movl (%rcx), %ecx
movl %ecx, 0x84(%rax)
addq $0xc8, %rdi
movq %rdi, 0x10(%rsp)
movl 0x80(%rax), %eax
movl %eax, %esi
callq 0x12a20
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, (%rax)
movl 0x84(%rax), %eax
movl %eax, %esi
callq 0x12a20
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x38(%rsp), %rax
movl 0x60(%rax), %eax
movl %eax, 0x6c(%rdi)
movq 0x38(%rsp), %rax
movl 0x88(%rax), %eax
movl %eax, 0x88(%rdi)
movq 0x38(%rsp), %rax
movl 0x70(%rax), %eax
movl %eax, 0x70(%rdi)
callq 0x2fb0
jmp 0x2f68
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x2f9a
jmp 0x2f90
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x12a40
jmp 0x2fa3
movq 0x18(%rsp), %rdi
callq 0x12a40
movq (%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2280
nopl (%rax)
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::calcCenter()
void PolyLine::calcCenter()
{
    CalculateFirstAndLastPoint();
    center = a;
    center.add(b);
    center.mul(0.5f);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6de0
movq (%rsp), %rsi
movq (%rsi), %rax
movq %rax, 0x58(%rsi)
movq %rsi, %rdi
addq $0x58, %rdi
addq $0x8, %rsi
callq 0x13d60
movq (%rsp), %rdi
addq $0x58, %rdi
movss 0x23026(%rip), %xmm0    # 0x26018
movss %xmm0, 0xc(%rsp)
leaq 0xc(%rsp), %rsi
callq 0x14df0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyDetector::RemoveZeroLengthLines()
void PolyDetector::RemoveZeroLengthLines(void)
{
    for (auto it = origLines.begin(); it != origLines.end(); )
    {
        if (!pointsDiffer(it->a, it->b)) // find a zero length line
            it = origLines.erase(it);
        else
            ++it;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x18, %rdi
callq 0x12a70
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x12aa0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x12ad0
testb $0x1, %al
jne 0x3d29
jmp 0x3da8
leaq 0x38(%rsp), %rdi
callq 0x12d10
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x12d10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0x6410
testb $0x1, %al
jne 0x3d99
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x12d90
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x12d20
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x3da3
leaq 0x38(%rsp), %rdi
callq 0x12b20
jmp 0x3d01
addq $0x48, %rsp
retq
nopl (%rax)
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: pointsDiffer(vec const&, vec const&, bool)
static bool pointsDiffer(const PointType &a, const PointType &b, bool aprox = true)
{
    // max precision is mandatory since this can break convex polys!
    if (aprox)
        return a.squaredist(b) >= minPointDiffSq;
    return a.x != b.x || a.y != b.y;
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x6452
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x12ba0
movss 0x1fbdc(%rip), %xmm1    # 0x26020
ucomiss %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x6496
movq 0x18(%rsp), %rax
movss (%rax), %xmm0
movq 0x10(%rsp), %rcx
movb $0x1, %al
ucomiss (%rcx), %xmm0
movb %al, 0xe(%rsp)
jne 0x648c
jp 0x648c
movq 0x18(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x10(%rsp), %rax
ucomiss 0x4(%rax), %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
addq $0xe0, %rdi
leaq 0x34(%rsp), %rsi
callq 0x12dd0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x128b0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x128e0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x12f00
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x128e0
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x12ec0
testb $0x1, %al
jne 0x6bd7
jmp 0x6bed
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x12f60
movb $0x1, 0x47(%rsp)
jmp 0x6bf2
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: simplifiedLine(PolyLine const&, PolyLine const&, PolyLine&)
static int simplifiedLine(const PolyLine &line_1, const PolyLine &line_2, PolyLine &ret)
{
    if (overlap(line_1, line_2))
    {
        if (line_1.contains(line_2))
        {
            ret = line_1;
            return 1;
        }
        if (line_2.contains(line_1))
        {
            ret = line_2;
            return 2;
        }

        PointType new_line_start_point;
        PointType new_line_end_point;

        // detects which point of <line_1> must be removed
        if (between(line_1.a, line_2.a, line_2.b)) {
            new_line_start_point = line_1.b;
        } else {
            new_line_start_point = line_1.a;
        }
        // detects which point of <line_2> must be removed
        if (between(line_2.a, line_1.a, line_1.b)) {
            new_line_end_point = line_2.b;
        } else {
            new_line_end_point = line_2.a;
        }

        // create a new line
        ret = PolyLine(new_line_start_point, new_line_end_point);
        return 3;
    }

    return 0;

}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq 0xb8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x64b0
testb $0x1, %al
jne 0x6c3d
jmp 0x6dba
movq 0xb8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x2460
testb $0x1, %al
jne 0x6c58
jmp 0x6c7d
movq 0xb8(%rsp), %rsi
movq 0xa8(%rsp), %rdi
callq 0x15310
movl $0x1, 0xc4(%rsp)
jmp 0x6dc5
movq 0xb0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x2460
testb $0x1, %al
jne 0x6c98
jmp 0x6cbd
movq 0xb0(%rsp), %rsi
movq 0xa8(%rsp), %rdi
callq 0x15310
movl $0x2, 0xc4(%rsp)
jmp 0x6dc5
leaq 0xa0(%rsp), %rdi
callq 0x13010
leaq 0x98(%rsp), %rdi
callq 0x13010
movq 0xb8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0xb0(%rsp), %rdx
addq $0x8, %rdx
callq 0x24f0
testb $0x1, %al
jne 0x6cfe
jmp 0x6d14
movq 0xb8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xa0(%rsp)
jmp 0x6d27
movq 0xb8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0xb8(%rsp), %rdx
addq $0x8, %rdx
callq 0x24f0
testb $0x1, %al
jne 0x6d4e
jmp 0x6d64
movq 0xb0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x98(%rsp)
jmp 0x6d77
movq 0xb0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x98(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x15130
movq 0xa8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x15390
leaq 0x8(%rsp), %rdi
callq 0x12a40
movl $0x3, 0xc4(%rsp)
jmp 0x6dc5
movl $0x0, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::CalculateFirstAndLastPoint()
void PolyLine::CalculateFirstAndLastPoint()
{
    if (!bComparePointOrder(a, b))
    {
        std::swap(a.x, b.x);
        std::swap(a.y, b.y);
        
        std::swap(aIdx, bIdx);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x6e50
testb $0x1, %al
jne 0x6e48
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x139a0
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x4, %rdi
addq $0x8, %rsi
addq $0x4, %rsi
callq 0x139a0
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x80, %rdi
addq $0x84, %rsi
callq 0x139e0
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x30, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x12a70
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x12aa0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x12ad0
testb $0x1, %al
jne 0x6ecf
jmp 0x6f01
leaq 0x30(%rsp), %rdi
callq 0x12b10
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x74(%rax)
jne 0x6ef3
movq 0x20(%rsp), %rdi
callq 0x6de0
jmp 0x6ef5
leaq 0x30(%rsp), %rdi
callq 0x12b20
jmp 0x6eba
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x12a70
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x30, %rdi
callq 0x12aa0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq -0x4508(%rip), %rdx     # 0x2a30
callq 0x13050
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movb %dl, %al
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
andb $0x1, %al
movb %al, 0x53(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x110, %rdi            # imm = 0x110
leaq 0x54(%rsp), %rsi
callq 0x140d0
movq 0x20(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x110, %rdi            # imm = 0x110
callq 0x14120
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x14100
testb $0x1, %al
jne 0x72a0
jmp 0x72fa
movq 0x20(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x14150
movq 0x18(%rsp), %rdi
movslq 0x4(%rax), %rsi
callq 0x12cf0
movq %rax, 0x38(%rsp)
testb $0x1, 0x53(%rsp)
je 0x72eb
movq 0x38(%rsp), %rax
testb $0x1, 0x74(%rax)
je 0x72eb
movq $0x0, 0x60(%rsp)
jmp 0x73c8
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x73c8
movq 0x20(%rsp), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0x14120
movq %rax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x14170
testb $0x1, %al
jne 0x7328
jmp 0x73bf
movq 0x20(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x110, %rdi            # imm = 0x110
callq 0x14190
movq 0x20(%rsp), %rdi
movl %eax, 0x10(%rsp)
addq $0x30, %rdi
callq 0x12b40
movq 0x20(%rsp), %rdi
movl %eax, 0x14(%rsp)
addq $0x110, %rdi            # imm = 0x110
callq 0x14120
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x14100
testb $0x1, %al
jne 0x7382
jmp 0x7395
leaq 0x48(%rsp), %rdi
callq 0x14150
movl 0x4(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x73a0
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movl %eax, 0x8(%rsp)
jmp 0x73a0
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %r8d
leaq 0x1f51c(%rip), %rdi     # 0x268d4
movb $0x0, %al
callq 0x2050
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x68, %rdi
addq $0x60, %rsi
callq 0x13a60
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
addq $0x68, %rdi
callq 0x13ab0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x13a90
testb $0x1, %al
jne 0x7432
jmp 0x743f
movl $0x0, 0x54(%rsp)
jmp 0x74de
movl $0x0, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x13ae0
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x128b0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x128e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x134e0
testb $0x1, %al
jne 0x748d
jmp 0x74d6
leaq 0x18(%rsp), %rdi
callq 0x13520
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
movl $0x1, %edx
callq 0x7240
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x74c8
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x74ca
leaq 0x18(%rsp), %rdi
callq 0x13530
jmp 0x7478
movl 0x2c(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyPol::center()
PointType PolyPol::center()
{
    if (p.empty())
        return PointType(0);
    
    PointType c(0);
    for (auto &pt : p)
        c.add(pt);
    c.div(p.size());
    
    return c;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x13c60
testb $0x1, %al
jne 0x991e
jmp 0x9930
leaq 0x40(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x13490
jmp 0x9a00
leaq 0x40(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x13490
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x13cb0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x13ce0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x13d10
testb $0x1, %al
jne 0x997a
jmp 0x99a4
leaq 0x28(%rsp), %rdi
callq 0x13d50
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x13d60
leaq 0x28(%rsp), %rdi
callq 0x13da0
jmp 0x9965
movq 0x8(%rsp), %rdi
callq 0x134c0
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, (%rsp)
testq %rax, %rax
movss %xmm0, 0x4(%rsp)
js 0x99e5
movss (%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x13dc0
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x13e00
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x13e70
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x13e30
testb $0x1, %al
jne 0x9a5e
jmp 0x9b0f
movq 0x10(%rsp), %rdi
callq 0x13cb0
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0x13ce0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x13d10
testb $0x1, %al
jne 0x9a91
jmp 0x9afe
leaq 0x40(%rsp), %rdi
callq 0x13ea0
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x13d50
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x6410
testb $0x1, %al
jne 0x9aef
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x13f20
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x13eb0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x9af9
leaq 0x30(%rsp), %rdi
callq 0x13da0
jmp 0x9a6d
jmp 0x9b00
leaq 0x40(%rsp), %rdi
callq 0x13f60
jmp 0x9a37
movb $0x1, %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x134c0
cmpq $0x2, %rax
jae 0x9b4d
movq 0x10(%rsp), %rdi
callq 0x13020
jmp 0x9bd9
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x134c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x9bd9
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x12a20
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x9baf
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6e50
testb $0x1, %al
jne 0x9bc7
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x9bc9
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x9b5f
addq $0x38, %rsp
retq
nop
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyDetector::findOrigLine(unsigned int)
PolyLine *PolyDetector::findOrigLine(uint32_t id)
{
    for (auto &l : origLines)
    {
        if (l.id == id)
        {
            return &l;
        }
    }
    logoutf("Cannot find origLine with id %u. nlines:%u", id, uint32_t(origLines.size()));
    return nullptr;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x12a70
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x12aa0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x12ad0
testb $0x1, %al
jne 0x9db3
jmp 0x9dea
leaq 0x20(%rsp), %rdi
callq 0x12b10
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x60(%rax), %eax
cmpl 0x34(%rsp), %eax
jne 0x9ddc
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x9e1d
jmp 0x9dde
leaq 0x20(%rsp), %rdi
callq 0x12b20
jmp 0x9d9e
movq 0x8(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x18, %rdi
callq 0x12b40
movl 0x4(%rsp), %esi
movl %eax, %edx
leaq 0x1cb0f(%rip), %rdi     # 0x2691c
movb $0x0, %al
callq 0x2050
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyCycle::Equals(PolyCycle const&) const
bool PolyCycle::Equals(const PolyCycle &p) const
{
    if (idx.size() != p.idx.size())
        return false;
    for (auto it1 = idx.cbegin(), it2 = p.idx.cbegin(); it1 != idx.cend(); ++it1, ++it2)
    {
        if (*it1 != *it2)
            return false;
    }
    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x13130
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x13130
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0xa033
movb $0x0, 0x47(%rsp)
jmp 0xa0be
movq 0x8(%rsp), %rdi
callq 0x14250
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14250
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
callq 0x14280
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x13170
testb $0x1, %al
jne 0xa075
jmp 0xa0b9
leaq 0x28(%rsp), %rdi
callq 0x131c0
movl (%rax), %eax
movl %eax, 0x4(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x131c0
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
je 0xa0a1
movb $0x0, 0x47(%rsp)
jmp 0xa0be
jmp 0xa0a3
leaq 0x28(%rsp), %rdi
callq 0x13240
leaq 0x20(%rsp), %rdi
callq 0x13240
jmp 0xa051
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0x14760
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jge 0xaa21
movb $0x0, 0x57(%rsp)
jmp 0xab0a
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x14760
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
je 0xaa48
movb $0x0, 0x57(%rsp)
jmp 0xab0a
movq 0x40(%rsp), %rdi
addq $0xc8, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x12a20
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
addq $0xc8, %rax
movq %rax, (%rsp)
movl 0x2c(%rsp), %esi
callq 0x14800
movq (%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x12a20
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdx
addq $0x58, %rdx
movq 0x30(%rsp), %rcx
addq $0x58, %rcx
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2680
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
je 0xaafe
movq 0x40(%rsp), %rax
cmpl $0x2, 0x60(%rax)
jbe 0xaafc
movq 0x8(%rsp), %rax
movl 0x60(%rax), %esi
movq 0x38(%rsp), %rax
movl 0x60(%rax), %edx
movq 0x30(%rsp), %rax
movl 0x60(%rax), %ecx
movl 0x2c(%rsp), %r8d
leaq 0x1bfcf(%rip), %rdi     # 0x26ac4
movb $0x0, %al
callq 0x2050
jmp 0xab00
jmp 0xab00
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x13140
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x13190
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x13170
testb $0x1, %al
jne 0xab70
jmp 0xabd2
leaq 0x28(%rsp), %rdi
callq 0x131c0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
movl $0x1, %edx
callq 0x7240
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xabc4
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xabe0
movq 0x8(%rsp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x7c(%rax)
jmp 0xabc6
leaq 0x28(%rsp), %rdi
callq 0x13240
jmp 0xab5b
movb $0x1, %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyLine::incTook(PolyDetector&)
uint32_t &PolyLine::incTook(PolyDetector &pd)
{
    if (took >= 2)
        return took;
    took++;
    if (took > 2)
    {
        logoutf("WARN: line %s taken %u times!", toString(pd).c_str(), took);
    }
    
    return took;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x2, 0x78(%rax)
jb 0xac11
movq 0x8(%rsp), %rax
addq $0x78, %rax
movq %rax, 0x50(%rsp)
jmp 0xac95
movq 0x8(%rsp), %rax
movl 0x78(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x78(%rax)
cmpl $0x2, 0x78(%rax)
jbe 0xac87
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x65a0
movq (%rsp), %rdi
callq 0x20b0
movq %rax, %rsi
movq 0x8(%rsp), %rax
movl 0x78(%rax), %edx
leaq 0x1bee5(%rip), %rdi     # 0x26b3d
xorl %eax, %eax
callq 0x2050
jmp 0xac61
leaq 0x20(%rsp), %rdi
callq 0x2100
jmp 0xac87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2100
jmp 0xac9f
movq 0x8(%rsp), %rax
addq $0x78, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x2280
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x1, %edx
callq 0x7240
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movl $0x1, %edx
callq 0x7240
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xb4ef
cmpq $0x0, 0x10(%rsp)
jne 0xb50e
leaq 0x1b5fb(%rip), %rdi     # 0x26af1
leaq 0x1abfb(%rip), %rsi     # 0x260f8
movl $0x7a0, %edx            # imm = 0x7A0
leaq 0x1b5ee(%rip), %rcx     # 0x26af7
callq 0x2120
movq (%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
addq $0x58, %rsi
callq 0x12ba0
movq (%rsp), %rsi
movss %xmm0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
addq $0x58, %rdi
addq $0x58, %rsi
callq 0x12ba0
movss %xmm0, 0x8(%rsp)
movss 0xc(%rsp), %xmm1
movss 0x8(%rsp), %xmm0
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x13cb0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x13ce0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x13d10
testb $0x1, %al
jne 0xbb20
jmp 0xbb5c
leaq 0x20(%rsp), %rdi
callq 0x13d50
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl $0x1, %edx
callq 0x6410
testb $0x1, %al
jne 0xbb4e
movb $0x0, 0x47(%rsp)
jmp 0xbb70
jmp 0xbb50
leaq 0x20(%rsp), %rdi
callq 0x13da0
jmp 0xbb0b
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x13550
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: PolyPol::TriangleArea(PolyDetector&)
double PolyPol::TriangleArea(PolyDetector &pd)
{
    if (p.size() <= 2)
        return 0.0f;
    double area = 0.0;

    auto c = center();
    for (auto &n : cycle.idx)
    {
        auto l = pd.findLine(n);
        if (!l)
            return 0.0f;
        area += abs(::Area(c, l->a, l->b));
    }
    //logoutf("area:%f", area);
    return area;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x134c0
cmpq $0x2, %rax
ja 0xbbb0
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0xbc93
movq (%rsp), %rdi
movq $0x0, 0x38(%rsp)
callq 0x9900
movq (%rsp), %rax
movlpd %xmm0, 0x30(%rsp)
addq $0x20, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x13140
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x13190
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x13170
testb $0x1, %al
jne 0xbc08
jmp 0xbc87
leaq 0x20(%rsp), %rdi
callq 0x131c0
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
movl $0x1, %edx
callq 0x7240
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xbc45
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0xbc93
movq 0x8(%rsp), %rsi
movq 0x8(%rsp), %rdx
addq $0x8, %rdx
leaq 0x30(%rsp), %rdi
callq 0xbca0
cvttss2si %xmm0, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cvtsi2sd %eax, %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x13240
jmp 0xbbf3
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x74(%rax)
je 0xc7d5
jmp 0xc854
movq 0x58(%rsp), %rax
cmpl $0x0, 0x60(%rax)
je 0xc84b
movq 0x18(%rsp), %rsi
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x65a0
movq 0x8(%rsp), %rdi
callq 0x20b0
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x1a6c3(%rip), %rdi     # 0x26edf
xorl %eax, %eax
callq 0x2050
jmp 0xc825
leaq 0x30(%rsp), %rdi
callq 0x2100
jmp 0xc84b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2100
jmp 0xc859
movq 0x18(%rsp), %rax
movb $0x1, 0x74(%rax)
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movl %edx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x98, %rdi
leaq 0x44(%rsp), %rsi
callq 0x13a60
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
addq $0x98, %rdi
callq 0x13ab0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x13a90
testb $0x1, %al
jne 0xcf3c
jmp 0xcf43
movb $0x0, 0x57(%rsp)
jmp 0xcfc2
leaq 0x38(%rsp), %rdi
callq 0x13ae0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x128b0
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x13ae0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x128e0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x12f00
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x13ae0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x128e0
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x134e0
andb $0x1, %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x14ee0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x12b60
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x12b60
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x13b50
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
callq 0x13040
movq 0x8(%rsp), %rdi
addq $0x98, %rdi
callq 0x13040
movq 0x8(%rsp), %rdi
addq $0xc8, %rdi
callq 0x13020
movq 0x8(%rsp), %rdi
addq $0xe0, %rdi
callq 0x13040
movq 0x8(%rsp), %rax
movl $0x0, 0x148(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rsp), %rax
subss 0x4(%rax), %xmm0
movq -0x20(%rsp), %rax
movss (%rax), %xmm2
movq -0x18(%rsp), %rax
subss (%rax), %xmm2
movq -0x18(%rsp), %rax
movss (%rax), %xmm1
movq -0x10(%rsp), %rax
subss (%rax), %xmm1
movq -0x20(%rsp), %rax
movss 0x4(%rax), %xmm3
movq -0x18(%rsp), %rax
subss 0x4(%rax), %xmm3
mulss %xmm3, %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x28(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd749
jp 0xd749
movl $0x0, -0x4(%rsp)
jmp 0xd767
movsd -0x28(%rsp), %xmm0
xorps %xmm1, %xmm1
movl $0x2, %eax
movl $0x1, %ecx
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x15220
movss 0x14(%rsp), %xmm1
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0xd84c
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x15260
movss 0x10(%rsp), %xmm0
ucomiss (%rax), %xmm0
jb 0xd84c
movq 0x20(%rsp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x28(%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
callq 0x15220
movss 0xc(%rsp), %xmm1
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0xd84c
movq 0x20(%rsp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
callq 0x15260
movss 0x8(%rsp), %xmm0
ucomiss (%rax), %xmm0
jb 0xd84c
movb $0x1, 0x37(%rsp)
jmp 0xd851
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x97(%rsp)
callq 0x2220
movq 0x18(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x13140
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x13190
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x13170
testb $0x1, %al
jne 0x1437d
jmp 0x14435
leaq 0x80(%rsp), %rdi
callq 0x131c0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movl (%rax), %esi
leaq 0x30(%rsp), %rdi
callq 0x132c0
jmp 0x143a2
leaq 0x126e5(%rip), %rdx     # 0x26a8e
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x13270
jmp 0x143ba
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x21f0
jmp 0x143cb
leaq 0x50(%rsp), %rdi
callq 0x2100
leaq 0x30(%rsp), %rdi
callq 0x2100
leaq 0x80(%rsp), %rdi
callq 0x13240
jmp 0x14362
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x14476
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x14429
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2100
leaq 0x30(%rsp), %rdi
callq 0x2100
jmp 0x14476
movq 0x8(%rsp), %rdi
callq 0x2270
testb $0x1, %al
jne 0x1444d
movq 0x8(%rsp), %rdi
callq 0x21e0
movb $0x1, 0x97(%rsp)
testb $0x1, 0x97(%rsp)
jne 0x14469
movq 0x8(%rsp), %rdi
callq 0x2100
movq 0x10(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x2100
movq 0x28(%rsp), %rdi
callq 0x2280
nopw (%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0xb7(%rsp)
movl 0x30(%rax), %esi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x132c0
movq 0x18(%rsp), %rdx
leaq 0x12424(%rip), %rsi     # 0x26faa
leaq 0x90(%rsp), %rdi
callq 0x13a10
jmp 0x14b95
movq (%rsp), %rdi
leaq 0x1240e(%rip), %rdx     # 0x26fae
leaq 0x90(%rsp), %rsi
callq 0x13270
jmp 0x14baf
leaq 0x90(%rsp), %rdi
callq 0x2100
leaq 0x70(%rsp), %rdi
callq 0x2100
movq 0x10(%rsp), %rdi
callq 0x13130
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x17ea0
jmp 0x14bdf
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x21f0
jmp 0x14bef
leaq 0x40(%rsp), %rdi
callq 0x2100
movq (%rsp), %rdi
leaq 0x11b16(%rip), %rsi     # 0x2671a
callq 0x2190
jmp 0x14c0b
movq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x142f0
jmp 0x14c1c
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x21f0
jmp 0x14c2c
leaq 0x20(%rsp), %rdi
callq 0x2100
movq (%rsp), %rdi
leaq 0x12377(%rip), %rsi     # 0x26fb8
callq 0x2190
jmp 0x14c48
movb $0x1, 0xb7(%rsp)
testb $0x1, 0xb7(%rsp)
jne 0x14ce4
jmp 0x14cdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x14c8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x2100
leaq 0x70(%rsp), %rdi
callq 0x2100
jmp 0x14cfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x14cf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2100
jmp 0x14cf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2100
jmp 0x14cf1
movq (%rsp), %rdi
callq 0x2100
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
retq
movq (%rsp), %rdi
callq 0x2100
movq 0x68(%rsp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x3a43
cmpl $0x0, -0x10(%rbp)
jle 0x3a43
movl -0x10(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x3a43
cmpl $0x8, -0x14(%rbp)
jg 0x3a43
movl -0x14(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x3a50
movq $0x0, -0x8(%rbp)
jmp 0x3af6
movl -0x10(%rbp), %edi
callq 0x48d0
movl %eax, -0x18(%rbp)
movl $0x30, %edi
callq 0x3260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x18(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x3c(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3130
movq %rax, -0x38(%rbp)
movl $0x7, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x7, %edi
movl $0x8, %esi
callq 0x3130
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x3150
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movq -0x8(%rbp), %rdx
subl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jg 0x3bbe
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3bd0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3c10
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x3ba1
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3c30
jmp 0x3bad
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3c60
jmp 0x3baf
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3b57
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)