// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/voronoi.cpp
// Function: Voronoi::Implementation::processEvent(CircleEvent const&)
void Voronoi::Implementation::processEvent(const CircleEvent& event)
{
    assert(event.left_int.pt_right == event.right_int.pt_left);
    assert(event.left_int.pt_right == event.right_int.pt_left);
    std::cerr << "--------\nProcessing Event at "
        << (event.circle.center.y - event.circle.radius)
        << " for: [" << event.left_int.pt_left << " -- "
        << event.left_int.pt_right << "], [" << event.right_int.pt_left << " -- "
        << event.right_int.pt_right << "]\n";

    // This essentially locks in the results of a single point (the middle part
    // of the two intersections, that means we must remove all events related to
    // this point


    // Suppose that intersections A and B meet (when the middle peak is beat out
    // by the side peaks):
    // l |   |     | r
    //   \  A/ |   |
    //    \ / v\B  /
    //     v    \ /
    //           v

    // |     |
    // |     |      |
    // \    C/      |
    //  \   / \     /
    //   \ /   \   /
    //    v     \ /
    //           v
    //
    // First we will remove the intersections A and B from the beach line
    //
    // Now if there are other intersections to the left of A, there would be an
    // event associated with A and that (l), same for an event to the right of
    // B (r). Those events can no longer occur because the intersections A (of
    // the left and center peak) and B (of the center and right peaks) will no
    // longer exist when the center peak has been hidden. Therefore we must
    // remove those events.
    //
    // We then have a new intersection on the beach line (C) which can have
    // events with l and r (when they exist)

    // find intersections to the left and right on the beach line, so we can
    // create a new event for when they meet
    {
    for(auto it1 = m_beach.begin(); it1 != m_beach.end(); ++it1) {
        auto it2 = it1;
        it2++;
        if(it2 != m_beach.end() && !m_beach_compare(*it1, *it2)) {
            std::cerr << it1->pt_left << ", " << it1->pt_right
                << " comes before " << it2->pt_left << ", " << it2->pt_right
                << "but it is not less!" << std::endl;
            throw -1;
        }
    }
    }

    bool success;
    BeachLineT::iterator it_new;
    std::cerr << "Looking up event location" << std::endl;
    auto it = m_beach.find(event.left_int);
    assert(it != m_beach.begin());
    assert(it != m_beach.end());

    std::cerr << "Left Int: [" << *(*it).pt_left << " -- " << *(*it).pt_right << std::endl;
    it--;
    auto left_neighbor = *it;
    it++;
    auto left_it = it;
    assert(left_it->pt_right == event.left_int.pt_right);
    assert(left_it->pt_left == event.left_int.pt_left);
    it++;
    auto right_it = it;
    assert(right_it->pt_right == event.right_int.pt_right);
    assert(right_it->pt_left == event.right_int.pt_left);
    std::cerr << "Right Int: [" << *(*it).pt_left << " -- " << *(*it).pt_right << std::endl;
    it++;
    auto right_neighbor = *it;
    assert(left_neighbor.pt_right == event.left_int.pt_left);
    assert(right_neighbor.pt_left == event.right_int.pt_right);

    // Find the 3 unique points so that we can create the necessary boundary
    // lines
    const Point* ptA = event.left_int.pt_left;
    const Point* ptB = event.left_int.pt_right;
    const Point* ptC = event.right_int.pt_right;

    // erase any other meetings with these two events
    m_events.erase(left_neighbor, event.left_int);
    m_events.erase(event.right_int, right_neighbor);

    // delete arc (i.e. erase both intersections related to the current event)
    std::cerr << "Erasing from beach" << std::endl;
    m_beach.erase(left_it);
    m_beach.erase(right_it);

    // Update sweep location so that our beach inserts go in the correct
    // location. Note we do this after the beach erase because technically at
    // this event the left and right intersections meet so there might be a
    // little strangeness with the ordering at sweep_y. Therefore just erase the
    // points first (above)
    *m_beach_compare.sweep_y = event.circle.center.y - event.circle.radius;

    // create new intersection of the outtermost arcs (left point of left
    // intersection and right point of right intersection)
    std::cerr << "Creating new beach point" << std::endl;
    std::tie(it_new, success) = m_beach.emplace(event.left_int.pt_left,
            event.right_int.pt_right);
    assert(success);

    // create new event(s) for the meeting of the new intersection and its
    // neighors, excepting the cases where 1) there is no neighboring
    // intersection because the neighbor is a special endpoint (nullptr for one
    // of its points) or 2) the neighboring intersection and new intersection
    // have the same three points that we just processed
    if(left_neighbor.pt_left != nullptr) {
        // Make sure that we aren't creating a new event for the points we just
        // processed
        auto event_points = std::make_tuple(left_neighbor.pt_left,
                it_new->pt_left, it_new->pt_right);
        if(!points_match(event_points, std::make_tuple(ptA, ptB, ptC)))
            m_events.insert(*m_beach_compare.sweep_y, left_neighbor, *it_new);
    }
    if(right_neighbor.pt_right != nullptr) {
        // Make sure that we aren't creating a new event for the points we just
        // processed
        auto event_points = std::make_tuple(it_new->pt_left, it_new->pt_right,
                right_neighbor.pt_right);
        if(!points_match(event_points, std::make_tuple(ptA, ptB, ptC)))
            m_events.insert(*m_beach_compare.sweep_y, *it_new, right_neighbor);
    }

//    Line line0{*event.left_int.pt_left, *event.left_int.pt_right};
//    Line line1{*event.right_int.pt_left, *event.right_int.pt_right};
//    lines.push_back(line0);
//    lines.push_back(line1);
//
//    // finish off boundaries related to the middle point
//    auto itb = m_bounds.find(left_neighbor.pt_left, left_neighbor.pt_right);
//    assert(itb != m_bounds.end());
//    itb->circle_pt = right_neighbor.pt_right;
//
//    itb = m_bounds.find(right_neighbor.pt_left, right_neighbor.pt_right);
//    assert(itb != m_bounds.end());
//    itb->circle_pt = left_neighbor.pt_left;
        for(const auto& tup_node: m_nodes) {
            assert(tup_node.second != nullptr);
            std::cerr << tup_node.second->x << ", "
                << tup_node.second->y << std::endl;
        }

    // The new center point connects to bisectors of each of the individual
    // pairs of points, these are rays from the center of the event circle to
    // each of the bisectors. Note that the first two points define the line
    // beginning, so all 3 possible pairs of the 3 points must show up
    Node::Ptr nodeCenter = getNode(ptA, ptB, ptC);
    Node::Ptr nodeAB = getNode(ptA, ptB);
    Node::Ptr nodeBC = getNode(ptB, ptC);
    Node::Ptr nodeCA = getNode(ptA, ptC);
    assert(nodeCenter != nullptr);
    assert(nodeAB != nullptr);
    assert(nodeBC != nullptr);
    assert(nodeCA != nullptr);

        for(const auto& tup_node: m_nodes) {
            assert(tup_node.second != nullptr);
            std::cerr << tup_node.second->x << ", "
                << tup_node.second->y << std::endl;
        }
    float distAB = perp(event.circle.center, *ptA, *ptB);
    float distBC = perp(event.circle.center, *ptB, *ptC);
    float distCA = perp(event.circle.center, *ptC, *ptA);
    if((distAB <= 0 && distBC <= 0 && distCA <= 0) ||
            (distAB >= 0 && distBC >= 0 && distCA >= 0)) {
        // point inside triangle
        addTriplet(nodeCenter, nodeAB, nodeBC, nodeCA);
    } else {
        // Whichever ever side of the triangle had the opposite sign as the
        // other two, is the one that we need to connect with
        std::cerr << "center = ["<< event.circle.center << "]"
            << "\n\ttriangle = [" << *ptA << ";"
            << "\n\t" << *ptB << ";"
            << "\n\t" << *ptC << "]"
            << std::endl;
        if((distBC <= 0 && (distCA >= 0 && distAB >=0)) ||
                (distBC >= 0 && (distCA <= 0 && distAB <=0))) {
            // distBC is the odd man out, move ptC into ptA so that A, B are
            // nearest
            addTriplet(nodeBC, nodeCenter, nodeCA, nodeAB);
        } else if((distCA <= 0 && (distAB >= 0 && distBC >=0)) ||
                (distCA >= 0 && (distAB <= 0 && distBC <=0))) {
            // distCA is the odd man out, swap nodeAB and nodeCA
            addTriplet(nodeCA, nodeCenter, nodeAB, nodeBC);
        } else {
            addTriplet(nodeAB, nodeCenter, nodeBC, nodeCA);
        }

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq 0x8(%rsi), %rax
cmpq 0x10(%rsi), %rax
jne 0x6f76
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsi), %rax
movq %rax, -0xb0(%rbp)
movq 0xdb16(%rip), %rdi      # 0x13ff0
leaq 0x7077(%rip), %rsi      # 0xd558
callq 0x31f0
leaq 0x20(%r14), %rcx
movq %rcx, -0xf8(%rbp)
movss 0x24(%r14), %xmm0
subss 0x28(%r14), %xmm0
movq %rax, %rdi
callq 0x3170
leaq 0x706a(%rip), %rsi      # 0xd576
movq %rax, %rdi
callq 0x31f0
movq (%r14), %rsi
movq %rax, %rdi
callq 0x3190
leaq 0x7058(%rip), %rbx      # 0xd57e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31f0
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x3190
leaq 0x703f(%rip), %rsi      # 0xd583
movq %rax, %rdi
callq 0x31f0
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x3190
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31f0
leaq 0x18(%r14), %rcx
movq %rcx, -0x60(%rbp)
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x3190
leaq 0x700a(%rip), %rsi      # 0xd588
movq %rax, %rdi
callq 0x31f0
leaq 0x10(%r15), %rax
movq %rax, -0x50(%rbp)
movq 0x28(%r15), %r12
leaq 0x18(%r15), %r13
movq %r15, -0xc8(%rbp)
leaq 0x8(%r15), %rbx
cmpq %r13, %r12
je 0x65dc
movq %r12, %rdi
callq 0x3230
cmpq %r13, %rax
je 0x65cf
movq %rax, %r15
leaq 0x20(%r12), %rsi
leaq 0x20(%rax), %rdx
movq %rbx, %rdi
callq 0x8bce
testb %al, %al
je 0x6ee1
movq %r12, %rdi
callq 0x3230
movq %rax, %r12
jmp 0x65a1
movq 0xda0d(%rip), %rdi      # 0x13ff0
leaq 0x6fc4(%rip), %rsi      # 0xd5ae
callq 0x31f0
movq %rax, %rdi
callq 0x30d0
movq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x9e60
movq %rax, %r15
movq -0xc8(%rbp), %rax
cmpq 0x28(%rax), %r15
je 0x6f95
cmpq %r13, %r15
je 0x6fb4
movq 0xd9c9(%rip), %rdi      # 0x13ff0
leaq 0x6fc4(%rip), %rsi      # 0xd5f2
callq 0x31f0
movq %rax, %r12
movq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x62cf
leaq 0x6f35(%rip), %rsi      # 0xd57e
movq %r12, %rdi
callq 0x31f0
movq %rax, %r12
movq 0x28(%r15), %rsi
movq %rax, %rdi
callq 0x62cf
movq %r12, %rdi
callq 0x30d0
movq %r15, %rdi
callq 0x3120
movups 0x20(%rax), %xmm0
movaps %xmm0, -0xf0(%rbp)
movq %rax, %rdi
callq 0x3230
movq %rax, %r12
movq 0x28(%rax), %rax
cmpq 0x8(%r14), %rax
jne 0x6fd3
movq 0x20(%r12), %rax
cmpq (%r14), %rax
jne 0x6ff2
movq %r12, %rdi
callq 0x3230
movq %rax, %r13
movq 0x28(%rax), %rax
movq -0x60(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7011
movq 0x20(%r13), %rax
movq -0xb0(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7030
movq 0xd917(%rip), %rdi      # 0x13ff0
leaq 0x6fd2(%rip), %rsi      # 0xd6b2
callq 0x31f0
movq %rax, %r15
movq 0x20(%r13), %rsi
movq %rax, %rdi
callq 0x62cf
leaq 0x6e83(%rip), %rsi      # 0xd57e
movq %r15, %rdi
callq 0x31f0
movq %rax, %r15
movq 0x28(%r13), %rsi
movq %rax, %rdi
callq 0x62cf
movq %r15, %rdi
callq 0x30d0
movq %r13, %rdi
callq 0x3230
movups 0x20(%rax), %xmm0
movaps %xmm0, -0xe0(%rbp)
movq (%r14), %rax
movq %rax, -0x30(%rbp)
cmpq %rax, -0xe8(%rbp)
jne 0x704f
movq %r12, -0x100(%rbp)
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
cmpq %rax, -0xe0(%rbp)
jne 0x706e
movq 0x8(%r14), %rax
movq %rax, -0x38(%rbp)
movq -0xc8(%rbp), %r15
leaq 0x40(%r15), %r12
leaq -0xf0(%rbp), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x8f32
leaq -0xe0(%rbp), %rdx
movq %r12, -0xb8(%rbp)
movq %r12, %rdi
movq -0xb0(%rbp), %rsi
callq 0x8f32
movq 0xd844(%rip), %rdi      # 0x13ff0
leaq 0x6f70(%rip), %rsi      # 0xd723
callq 0x31f0
movq %rax, %rdi
callq 0x30d0
movq -0x50(%rbp), %r12
movq %r12, %rdi
movq -0x100(%rbp), %rsi
callq 0x9ef6
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %r13
callq 0x9ef6
movss 0x24(%r14), %xmm0
subss 0x28(%r14), %xmm0
movq 0x8(%r15), %rax
movss %xmm0, (%rax)
leaq 0x6f3a(%rip), %rsi      # 0xd736
movq 0xd7ed(%rip), %rdi      # 0x13ff0
callq 0x31f0
movq %rax, %rdi
callq 0x30d0
movq %r12, %rdi
movq %r14, %rsi
movq -0x60(%rbp), %rdx
callq 0x9f56
testb $0x1, %dl
je 0x708d
movq %rax, %r14
movq -0xf0(%rbp), %rax
testq %rax, %rax
movq -0xc0(%rbp), %r15
je 0x6899
movq 0x20(%r14), %rcx
movq 0x28(%r14), %rdx
leaq -0x260(%rbp), %rdi
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
leaq -0x248(%rbp), %rsi
movq %r15, (%rsi)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%rsi)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rsi)
callq 0x59d0
testb %al, %al
jne 0x6899
leaq 0x20(%r14), %rdx
movq (%rbx), %rax
cvtss2sd (%rax), %xmm0
leaq -0xf0(%rbp), %rsi
movq -0xb8(%rbp), %rdi
callq 0x9032
movq -0xd8(%rbp), %rax
testq %rax, %rax
je 0x6903
movq 0x20(%r14), %rcx
movq 0x28(%r14), %rdx
leaq -0x230(%rbp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
leaq -0x218(%rbp), %rsi
movq %r15, (%rsi)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%rsi)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rsi)
callq 0x59d0
testb %al, %al
jne 0x6903
addq $0x20, %r14
movq (%rbx), %rax
cvtss2sd (%rax), %xmm0
leaq -0xe0(%rbp), %rdx
movq -0xb8(%rbp), %rdi
movq %r14, %rsi
callq 0x9032
leaq 0xa0(%r13), %r15
movq 0xd6df(%rip), %rbx      # 0x13ff0
leaq 0x676f(%rip), %r14      # 0xd087
movq %r15, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x6965
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x6ea3
movss (%rax), %xmm0
movq %rbx, %rdi
callq 0x3170
movq %rax, %rdi
movq %r14, %rsi
callq 0x31f0
movq 0x20(%r12), %rcx
movss 0x4(%rcx), %xmm0
movq %rax, %rdi
callq 0x3170
movq %rax, %rdi
callq 0x30d0
jmp 0x691b
leaq -0xa0(%rbp), %rdi
movq %r13, %rsi
movq -0x30(%rbp), %r14
movq %r14, %rdx
movq -0x38(%rbp), %rbx
movq %rbx, %rcx
movq -0xc0(%rbp), %r12
movq %r12, %r8
callq 0x7236
leaq -0x90(%rbp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x73bc
leaq -0x80(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x73bc
leaq -0x70(%rbp), %rdi
movq %r13, %rsi
movq -0x30(%rbp), %rdx
movq %r12, %rcx
callq 0x73bc
cmpq $0x0, -0xa0(%rbp)
je 0x70ac
cmpq $0x0, -0x90(%rbp)
je 0x70cb
cmpq $0x0, -0x80(%rbp)
je 0x70ea
cmpq $0x0, -0x70(%rbp)
je 0x7109
movq 0xd5f1(%rip), %rbx      # 0x13ff0
leaq 0x6681(%rip), %r14      # 0xd087
movq (%r15), %r15
testq %r15, %r15
je 0x6a4d
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x6ec2
movss (%rax), %xmm0
movq %rbx, %rdi
callq 0x3170
movq %rax, %rdi
movq %r14, %rsi
callq 0x31f0
movq 0x20(%r15), %rcx
movss 0x4(%rcx), %xmm0
movq %rax, %rdi
callq 0x3170
movq %rax, %rdi
callq 0x30d0
jmp 0x6a06
movq -0xf8(%rbp), %r14
movq %r14, %rdi
movq -0x30(%rbp), %rbx
movq %rbx, %rsi
movq -0x38(%rbp), %r15
movq %r15, %rdx
callq 0x932a
movaps %xmm0, -0x60(%rbp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x932a
movaps %xmm0, -0x50(%rbp)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x932a
movaps %xmm0, -0xb0(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x60(%rbp), %xmm0
jb 0x6ab0
ucomiss -0x50(%rbp), %xmm0
jb 0x6ab0
xorps %xmm1, %xmm1
ucomiss -0xb0(%rbp), %xmm1
jae 0x6ada
movaps -0x60(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jb 0x6bb5
movaps -0x50(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jb 0x6bb5
movaps -0xb0(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jb 0x6bb5
leaq -0x200(%rbp), %rbx
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq 0x98f2
leaq -0x1f0(%rbp), %r14
leaq -0x90(%rbp), %rsi
movq %r14, %rdi
callq 0x98f2
leaq -0x1e0(%rbp), %r15
leaq -0x80(%rbp), %rsi
movq %r15, %rdi
callq 0x98f2
leaq -0x1d0(%rbp), %r12
leaq -0x70(%rbp), %rsi
movq %r12, %rdi
callq 0x98f2
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x7512
leaq -0x1c8(%rbp), %rdi
leaq -0x1d8(%rbp), %rbx
leaq -0x1e8(%rbp), %r14
leaq -0x1f8(%rbp), %r15
callq 0x4b24
movq %rbx, %rdi
callq 0x4b24
movq %r14, %rdi
callq 0x4b24
movq %r15, %rdi
callq 0x4b24
leaq -0x68(%rbp), %rdi
callq 0x4b24
leaq -0x78(%rbp), %rdi
callq 0x4b24
leaq -0x88(%rbp), %rdi
callq 0x4b24
leaq -0x98(%rbp), %rdi
callq 0x4b24
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd434(%rip), %rdi      # 0x13ff0
leaq 0x6bfb(%rip), %rsi      # 0xd7be
callq 0x31f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x62cf
leaq 0x6bec(%rip), %rsi      # 0xd7c9
movq %rbx, %rdi
callq 0x31f0
leaq 0x6bdf(%rip), %rsi      # 0xd7cb
movq %rax, %rdi
callq 0x31f0
movq %rax, %rbx
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x62cf
leaq 0x6bd0(%rip), %rsi      # 0xd7da
movq %rbx, %rdi
callq 0x31f0
leaq 0x6bc3(%rip), %rsi      # 0xd7dc
movq %rax, %rdi
callq 0x31f0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x62cf
leaq 0x6ba4(%rip), %rsi      # 0xd7da
movq %rbx, %rdi
callq 0x31f0
leaq 0x6b97(%rip), %rsi      # 0xd7dc
movq %rax, %rdi
callq 0x31f0
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
callq 0x62cf
leaq 0x6b67(%rip), %rsi      # 0xd7c9
movq %rbx, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x30d0
xorps %xmm0, %xmm0
movaps -0x50(%rbp), %xmm1
ucomiss %xmm0, %xmm1
setae %al
ucomiss %xmm1, %xmm0
setae %cl
xorps %xmm1, %xmm1
movaps -0x60(%rbp), %xmm3
cmpleps %xmm3, %xmm1
xorps %xmm2, %xmm2
movaps -0xb0(%rbp), %xmm4
cmpleps %xmm4, %xmm2
andps %xmm1, %xmm2
movd %xmm2, %edx
testb %cl, %dl
jne 0x6d95
movaps %xmm3, %xmm1
cmpleps %xmm0, %xmm1
movaps %xmm4, %xmm2
cmpleps %xmm0, %xmm2
andps %xmm1, %xmm2
movd %xmm2, %ecx
andb %al, %cl
jne 0x6d95
ucomiss %xmm0, %xmm4
setae %al
ucomiss %xmm4, %xmm0
setae %cl
xorps %xmm1, %xmm1
movaps -0x50(%rbp), %xmm4
cmpleps %xmm4, %xmm1
xorps %xmm2, %xmm2
cmpleps %xmm3, %xmm2
andps %xmm1, %xmm2
movd %xmm2, %edx
testb %cl, %dl
jne 0x6e1c
cmpleps %xmm0, %xmm4
cmpleps %xmm0, %xmm3
andps %xmm4, %xmm3
movd %xmm3, %ecx
andb %al, %cl
jne 0x6e1c
leaq -0x140(%rbp), %rbx
leaq -0x90(%rbp), %rsi
movq %rbx, %rdi
callq 0x98f2
leaq -0x130(%rbp), %r14
leaq -0xa0(%rbp), %rsi
movq %r14, %rdi
callq 0x98f2
leaq -0x120(%rbp), %r15
leaq -0x80(%rbp), %rsi
movq %r15, %rdi
callq 0x98f2
leaq -0x110(%rbp), %r12
leaq -0x70(%rbp), %rsi
movq %r12, %rdi
callq 0x98f2
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x7512
leaq -0x108(%rbp), %rdi
leaq -0x118(%rbp), %rbx
leaq -0x128(%rbp), %r14
leaq -0x138(%rbp), %r15
jmp 0x6b5c
leaq -0x1c0(%rbp), %rbx
leaq -0x80(%rbp), %rsi
movq %rbx, %rdi
callq 0x98f2
leaq -0x1b0(%rbp), %r14
leaq -0xa0(%rbp), %rsi
movq %r14, %rdi
callq 0x98f2
leaq -0x1a0(%rbp), %r15
leaq -0x70(%rbp), %rsi
movq %r15, %rdi
callq 0x98f2
leaq -0x190(%rbp), %r12
leaq -0x90(%rbp), %rsi
movq %r12, %rdi
callq 0x98f2
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x7512
leaq -0x188(%rbp), %rdi
leaq -0x198(%rbp), %rbx
leaq -0x1a8(%rbp), %r14
leaq -0x1b8(%rbp), %r15
jmp 0x6b5c
leaq -0x180(%rbp), %rbx
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x98f2
leaq -0x170(%rbp), %r14
leaq -0xa0(%rbp), %rsi
movq %r14, %rdi
callq 0x98f2
leaq -0x160(%rbp), %r15
leaq -0x90(%rbp), %rsi
movq %r15, %rdi
callq 0x98f2
leaq -0x150(%rbp), %r12
leaq -0x80(%rbp), %rsi
movq %r12, %rdi
callq 0x98f2
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x7512
leaq -0x148(%rbp), %rdi
leaq -0x158(%rbp), %rbx
leaq -0x168(%rbp), %r14
leaq -0x178(%rbp), %r15
jmp 0x6b5c
leaq 0x68ad(%rip), %rdi      # 0xd757
leaq 0x6459(%rip), %rsi      # 0xd30a
leaq 0x6660(%rip), %rcx      # 0xd518
movl $0x2e5, %edx            # imm = 0x2E5
callq 0x3130
leaq 0x688e(%rip), %rdi      # 0xd757
leaq 0x643a(%rip), %rsi      # 0xd30a
leaq 0x6641(%rip), %rcx      # 0xd518
movl $0x2f8, %edx            # imm = 0x2F8
callq 0x3130
movq 0x20(%r12), %rsi
movq 0xd103(%rip), %rdi      # 0x13ff0
callq 0x31b0
leaq 0x618e(%rip), %rbx      # 0xd087
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31f0
movq 0x28(%r12), %rsi
movq %rax, %rdi
callq 0x31b0
leaq 0x6673(%rip), %rsi      # 0xd58b
movq %rax, %rdi
callq 0x31f0
movq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x31b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31f0
movq 0x28(%r15), %rsi
movq %rax, %rdi
callq 0x31b0
leaq 0x6650(%rip), %rsi      # 0xd59a
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x30d0
pushq $0x4
popq %rdi
callq 0x30e0
orl $-0x1, (%rax)
movq 0xd04c(%rip), %rsi      # 0x13fb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3340
leaq 0x6568(%rip), %rdi      # 0xd4e5
leaq 0x6386(%rip), %rsi      # 0xd30a
leaq 0x658d(%rip), %rcx      # 0xd518
movl $0x254, %edx            # imm = 0x254
callq 0x3130
leaq 0x662c(%rip), %rdi      # 0xd5c8
leaq 0x6367(%rip), %rsi      # 0xd30a
leaq 0x656e(%rip), %rcx      # 0xd518
movl $0x290, %edx            # imm = 0x290
callq 0x3130
leaq 0x6623(%rip), %rdi      # 0xd5de
leaq 0x6348(%rip), %rsi      # 0xd30a
leaq 0x654f(%rip), %rcx      # 0xd518
movl $0x291, %edx            # imm = 0x291
callq 0x3130
leaq 0x6624(%rip), %rdi      # 0xd5fe
leaq 0x6329(%rip), %rsi      # 0xd30a
leaq 0x6530(%rip), %rcx      # 0xd518
movl $0x298, %edx            # imm = 0x298
callq 0x3130
leaq 0x6632(%rip), %rdi      # 0xd62b
leaq 0x630a(%rip), %rsi      # 0xd30a
leaq 0x6511(%rip), %rcx      # 0xd518
movl $0x299, %edx            # imm = 0x299
callq 0x3130
leaq 0x663e(%rip), %rdi      # 0xd656
leaq 0x62eb(%rip), %rsi      # 0xd30a
leaq 0x64f2(%rip), %rcx      # 0xd518
movl $0x29c, %edx            # imm = 0x29C
callq 0x3130
leaq 0x664e(%rip), %rdi      # 0xd685
leaq 0x62cc(%rip), %rsi      # 0xd30a
leaq 0x64d3(%rip), %rcx      # 0xd518
movl $0x29d, %edx            # imm = 0x29D
callq 0x3130
leaq 0x6669(%rip), %rdi      # 0xd6bf
leaq 0x62ad(%rip), %rsi      # 0xd30a
leaq 0x64b4(%rip), %rcx      # 0xd518
movl $0x2a1, %edx            # imm = 0x2A1
callq 0x3130
leaq 0x667b(%rip), %rdi      # 0xd6f0
leaq 0x628e(%rip), %rsi      # 0xd30a
leaq 0x6495(%rip), %rcx      # 0xd518
movl $0x2a2, %edx            # imm = 0x2A2
callq 0x3130
leaq 0x66bb(%rip), %rdi      # 0xd74f
leaq 0x626f(%rip), %rsi      # 0xd30a
leaq 0x6476(%rip), %rcx      # 0xd518
movl $0x2bf, %edx            # imm = 0x2BF
callq 0x3130
leaq 0x66bf(%rip), %rdi      # 0xd772
leaq 0x6250(%rip), %rsi      # 0xd30a
leaq 0x6457(%rip), %rcx      # 0xd518
movl $0x2f2, %edx            # imm = 0x2F2
callq 0x3130
leaq 0x66b6(%rip), %rdi      # 0xd788
leaq 0x6231(%rip), %rsi      # 0xd30a
leaq 0x6438(%rip), %rcx      # 0xd518
movl $0x2f3, %edx            # imm = 0x2F3
callq 0x3130
leaq 0x66a9(%rip), %rdi      # 0xd79a
leaq 0x6212(%rip), %rsi      # 0xd30a
leaq 0x6419(%rip), %rcx      # 0xd518
movl $0x2f4, %edx            # imm = 0x2F4
callq 0x3130
leaq 0x669c(%rip), %rdi      # 0xd7ac
leaq 0x61f3(%rip), %rsi      # 0xd30a
leaq 0x63fa(%rip), %rcx      # 0xd518
movl $0x2f5, %edx            # imm = 0x2F5
callq 0x3130
movq %rax, %rbx
leaq -0x148(%rbp), %rdi
callq 0x4b24
leaq -0x158(%rbp), %rdi
callq 0x4b24
leaq -0x168(%rbp), %rdi
callq 0x4b24
leaq -0x178(%rbp), %rdi
jmp 0x71e9
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x4b24
leaq -0x118(%rbp), %rdi
callq 0x4b24
leaq -0x128(%rbp), %rdi
callq 0x4b24
leaq -0x138(%rbp), %rdi
jmp 0x71e9
movq %rax, %rbx
leaq -0x188(%rbp), %rdi
callq 0x4b24
leaq -0x198(%rbp), %rdi
callq 0x4b24
leaq -0x1a8(%rbp), %rdi
callq 0x4b24
leaq -0x1b8(%rbp), %rdi
jmp 0x71e9
movq %rax, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x4b24
leaq -0x1d8(%rbp), %rdi
callq 0x4b24
leaq -0x1e8(%rbp), %rdi
callq 0x4b24
leaq -0x1f8(%rbp), %rdi
callq 0x4b24
jmp 0x7204
movq %rax, %rbx
jmp 0x720d
movq %rax, %rbx
jmp 0x7216
movq %rax, %rbx
jmp 0x7222
jmp 0x7201
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x4b24
leaq -0x78(%rbp), %rdi
callq 0x4b24
leaq -0x88(%rbp), %rdi
callq 0x4b24
leaq -0x98(%rbp), %rdi
callq 0x4b24
movq %rbx, %rdi
callq 0x3360