LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/voronoi.cpp
// Function: solveCircle(Vector const&, Vector const&, Vector const&)
Circle solveCircle(const Point& p, const Point& q, const Point& r)
{
    // find minimal point
    Circle circle;
    circle.center.x =
        0.5*(p.y*sqr(q.x) + p.y*sqr(q.y) - (p.y - q.y)*sqr(r.x) -
                (p.y - q.y)*sqr(r.y) - (sqr(p.x) + sqr(p.y))*q.y +
                (sqr(p.x) + sqr(p.y) - sqr(q.x) - sqr(q.y))*r.y) /
        (p.y*q.x - p.x*q.y - (p.y - q.y)*r.x + (p.x - q.x)*r.y);

    circle.center.y =
        -0.5*(p.x*sqr(q.x) + p.x*sqr(q.y) - (p.x - q.x)*sqr(r.x) -
                (p.x - q.x)*sqr(r.y) - (sqr(p.x) + sqr(p.y))*q.x +
                (sqr(p.x) + sqr(p.y) - sqr(q.x) - sqr(q.y))*r.x) /
        (p.y*q.x - p.x*q.y - (p.y - q.y)*r.x + (p.x - q.x)*r.y);

    circle.radius = sqrt(sqr(p.x - circle.center.x) + sqr(p.y - circle.center.y));
    return circle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss (%rdi), %xmm6
movss 0x4(%rdi), %xmm9
cvtss2sd %xmm9, %xmm3
movss (%rsi), %xmm0
movss %xmm0, -0x4(%rbp)
movss 0x4(%rsi), %xmm5
cvtss2sd %xmm0, %xmm10
cvtss2sd %xmm5, %xmm0
movaps %xmm0, %xmm4
mulsd %xmm0, %xmm4
movapd %xmm4, %xmm11
mulsd %xmm3, %xmm11
movapd %xmm3, %xmm7
cvtss2sd %xmm6, %xmm8
movsd %xmm8, -0x18(%rbp)
mulsd %xmm8, %xmm8
mulsd %xmm3, %xmm3
addsd %xmm8, %xmm3
mulsd %xmm3, %xmm0
movsd %xmm0, -0x10(%rbp)
movapd %xmm3, %xmm8
mulsd %xmm10, %xmm3
mulsd %xmm10, %xmm10
mulsd %xmm10, %xmm7
addsd %xmm11, %xmm7
movaps %xmm9, %xmm14
subss %xmm5, %xmm14
movss (%rdx), %xmm15
movss 0x4(%rdx), %xmm12
cvtss2sd %xmm12, %xmm11
movaps %xmm11, %xmm13
subsd %xmm10, %xmm8
subsd %xmm4, %xmm8
mulsd %xmm8, %xmm11
cvtss2sd %xmm15, %xmm2
mulsd %xmm2, %xmm8
mulsd %xmm2, %xmm2
cvtss2sd %xmm14, %xmm1
movaps %xmm1, %xmm0
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm7
mulsd %xmm13, %xmm13
mulsd %xmm13, %xmm1
subsd %xmm1, %xmm7
subsd -0x10(%rbp), %xmm7
addsd %xmm7, %xmm11
mulss %xmm6, %xmm5
movaps %xmm9, %xmm0
movss -0x4(%rbp), %xmm7
mulss %xmm7, %xmm0
subss %xmm5, %xmm0
mulss %xmm15, %xmm14
subss %xmm14, %xmm0
movaps %xmm6, %xmm1
subss %xmm7, %xmm1
mulss %xmm1, %xmm12
addss %xmm0, %xmm12
movsd -0x18(%rbp), %xmm0
mulsd %xmm0, %xmm4
mulsd %xmm0, %xmm10
addsd %xmm4, %xmm10
cvtss2sd %xmm1, %xmm0
mulsd %xmm0, %xmm2
subsd %xmm2, %xmm10
mulsd %xmm0, %xmm13
subsd %xmm13, %xmm10
subsd %xmm3, %xmm10
addsd %xmm10, %xmm8
mulsd 0x6be6(%rip), %xmm11    # 0xd038
cvtss2sd %xmm12, %xmm1
divsd %xmm1, %xmm11
cvtsd2ss %xmm11, %xmm0
mulsd 0x6df6(%rip), %xmm8     # 0xd260
divsd %xmm1, %xmm8
cvtsd2ss %xmm8, %xmm1
subss %xmm0, %xmm6
cvtss2sd %xmm6, %xmm2
mulsd %xmm2, %xmm2
subss %xmm1, %xmm9
cvtss2sd %xmm9, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm2, %xmm3
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
sqrtsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/voronoi.cpp
// Function: Voronoi::Implementation::getNode(Vector const*, Vector const*, Vector const*)
Voronoi::Node::Ptr Voronoi::Implementation::getNode(
        const Point* ptA, const Point* ptB, const Point* ptC)
{
    orderPoints(ptA, ptB, ptC);
    auto result = m_nodes.emplace(std::make_tuple(ptA, ptB, ptC), nullptr);

    // if node exists, just return it
    if(!result.second) {
        assert(result.first->second != nullptr);
        return result.first->second;
    }

    // create and fill out the new node
    auto circle = solveCircle(*ptA, *ptB, *ptC);

    // need to construct a new node and add its parents and location
    auto new_node = std::make_shared<Node>();
    result.first->second = new_node;

    // Add parents
    new_node->parents.insert((ptA - m_points->data()) / sizeof(Point));
    new_node->parents.insert((ptB - m_points->data()) / sizeof(Point));
    new_node->parents.insert((ptC - m_points->data()) / sizeof(Point));

    // Add position
    new_node->x = circle.center.x;
    new_node->y = circle.center.y;

    return new_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpq %rcx, %rdx
movq %rcx, %r13
cmovaq %rdx, %r13
cmovaq %rcx, %rdx
cmpq %r8, %r13
movq %r8, %r14
cmovaq %r13, %r14
cmovaq %r8, %r13
cmpq %r13, %rdx
movq %r13, %r12
cmovaq %rdx, %r12
cmovbeq %rdx, %r13
movq %rsi, -0x30(%rbp)
leaq 0x90(%rsi), %rdi
leaq -0x48(%rbp), %rsi
movq %r14, (%rsi)
movq %r12, 0x8(%rsi)
movq %r13, 0x10(%rsi)
leaq -0x68(%rbp), %rdx
andq $0x0, (%rdx)
callq 0xb80a
movq %rax, %r15
testb $0x1, %dl
je 0x7359
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x6309
movaps %xmm0, -0x60(%rbp)
movq %rbx, %rdi
callq 0x942d
addq $0x20, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x990a
movq (%rbx), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %r15
movq 0xe0(%r15), %rax
subq (%rax), %r13
sarq $0x3, %r13
shrq $0x3, %r13
leaq -0x48(%rbp), %rsi
movq %r13, (%rsi)
callq 0xbfa4
movq (%rbx), %rdi
addq $0x8, %rdi
movq 0xe0(%r15), %rax
subq (%rax), %r12
sarq $0x3, %r12
shrq $0x3, %r12
leaq -0x48(%rbp), %rsi
movq %r12, (%rsi)
callq 0xbfa4
movq (%rbx), %rdi
addq $0x8, %rdi
movq 0xe0(%r15), %rax
subq (%rax), %r14
sarq $0x3, %r14
shrq $0x3, %r14
leaq -0x48(%rbp), %rsi
movq %r14, (%rsi)
callq 0xbfa4
movq (%rbx), %rax
movaps -0x60(%rbp), %xmm0
movss %xmm0, (%rax)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x4(%rax)
jmp 0x736f
cmpq $0x0, 0x20(%r15)
je 0x7381
addq $0x20, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x98f2
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x666f(%rip), %rdi      # 0xd9f7
leaq 0x5f7b(%rip), %rsi      # 0xd30a
leaq 0x6681(%rip), %rcx      # 0xda17
movl $0x3d6, %edx            # imm = 0x3D6
callq 0x3130
jmp 0x73a4
jmp 0x73a4
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4b24
movq %r14, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/voronoi.cpp
// Function: Voronoi::Implementation::getNode(Vector const*, Vector const*)
Voronoi::Node::Ptr Voronoi::Implementation::getNode(
        const Point* ptA, const Point* ptB)
{
    if(ptA > ptB) std::swap(ptA, ptB);
    auto result = m_nodes.emplace(std::make_tuple(ptA, ptB, nullptr), nullptr);

    // if node exists, just return it
    if(!result.second) {
        assert(result.first->second != nullptr);
        return result.first->second;
    }

    // need to construct a new node and add its parents and location
    auto new_node = std::make_shared<Node>();
    result.first->second = new_node;

    // Add parents
    new_node->parents.insert((ptA - m_points->data()) / sizeof(Point));
    new_node->parents.insert((ptB - m_points->data()) / sizeof(Point));

    // Add position
    new_node->x = (ptA->x + ptB->x)*0.5;
    new_node->y = (ptA->y + ptB->y)*0.5;

    return new_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
cmpq %rcx, %rdx
movq %rcx, %r13
cmovaq %rdx, %r13
movq %rsi, %r15
cmovaq %rcx, %r14
leaq -0x48(%rbp), %rsi
andq $0x0, (%rsi)
movq %rdi, %rbx
leaq 0x90(%r15), %rdi
movq %r13, 0x8(%rsi)
movq %r14, 0x10(%rsi)
leaq -0x30(%rbp), %rdx
andq $0x0, (%rdx)
callq 0xc0e0
movq %rax, %r12
testb $0x1, %dl
je 0x74b0
movq %rbx, %rdi
callq 0x942d
addq $0x20, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x990a
movq (%rbx), %rdi
addq $0x8, %rdi
movq 0xe0(%r15), %rax
movq %r14, %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
shrq $0x3, %rcx
leaq -0x48(%rbp), %rsi
movq %rcx, (%rsi)
callq 0xbfa4
movq (%rbx), %rdi
addq $0x8, %rdi
movq 0xe0(%r15), %rax
movq %r13, %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
shrq $0x3, %rcx
leaq -0x48(%rbp), %rsi
movq %rcx, (%rsi)
callq 0xbfa4
movss (%r14), %xmm0
addss (%r13), %xmm0
movss 0x5e42(%rip), %xmm1     # 0xd2d0
mulss %xmm1, %xmm0
movq (%rbx), %rax
movss %xmm0, (%rax)
movss 0x4(%r14), %xmm0
addss 0x4(%r13), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x4(%rax)
jmp 0x74c7
cmpq $0x0, 0x20(%r12)
je 0x74d9
addq $0x20, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x98f2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6517(%rip), %rdi      # 0xd9f7
leaq 0x5e23(%rip), %rsi      # 0xd30a
leaq 0x658a(%rip), %rcx      # 0xda78
movl $0x3f5, %edx            # imm = 0x3F5
callq 0x3130
jmp 0x74fa
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4b24
movq %r14, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/voronoi.cpp
// Function: Voronoi::Implementation::addEdge(std::shared_ptr<Voronoi::Node>, std::shared_ptr<Voronoi::Node>)
Voronoi::Edge::Ptr Voronoi::Implementation::addEdge(
        Node::Ptr nodeA,
        Node::Ptr nodeB)
{
    // the edges parents are the parents in common between the two input nodes
    std::set<size_t> common;
    std::set_intersection(
            nodeA->parents.begin(), nodeA->parents.end(),
            nodeB->parents.begin(), nodeB->parents.end(),
            std::inserter(common, common.begin()));

    auto out = std::make_shared<Edge>();
    out->parents = common;
    out->nodes[0] = nodeA;
    out->nodes[1] = nodeB;
    std::cerr << "adding edge!" << std::endl;
    std::cerr << "edge = [" << nodeA->x << ", " << nodeA->y << ";"
        << nodeB->x << ", " << nodeB->y << "]" << std::endl;
    m_edges.push_back(out);
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r12
leaq -0x48(%rbp), %r9
andl $0x0, (%r9)
andq $0x0, 0x8(%r9)
movq %r9, 0x10(%r9)
movq %r9, 0x18(%r9)
andq $0x0, 0x20(%r9)
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
movq 0x20(%rsi), %rdi
addq $0x10, %rsi
movq (%rcx), %rcx
movq 0x20(%rcx), %rdx
addq $0x10, %rcx
leaq -0x50(%rbp), %r8
callq 0xc1cc
movq %rbx, %rdi
callq 0x9449
movq (%rbx), %rdi
leaq -0x50(%rbp), %rsi
callq 0x997a
movq (%rbx), %rdi
addq $0x30, %rdi
movq %r12, %rsi
callq 0x990a
movq (%rbx), %rdi
addq $0x40, %rdi
movq %r15, %rsi
callq 0x990a
movq 0xbc8f(%rip), %rdi      # 0x13ff0
leaq 0x5762(%rip), %rsi      # 0xdaca
callq 0x31f0
movq %rax, %rdi
callq 0x30d0
movq 0xbc74(%rip), %rdi      # 0x13ff0
leaq 0x5754(%rip), %rsi      # 0xdad7
callq 0x31f0
movq (%r12), %rcx
movss (%rcx), %xmm0
movq %rax, %rdi
callq 0x3170
leaq 0x4ce8(%rip), %rsi      # 0xd087
movq %rax, %rdi
callq 0x31f0
movq (%r12), %rcx
movss 0x4(%rcx), %xmm0
movq %rax, %rdi
callq 0x3170
leaq 0x541b(%rip), %rsi      # 0xd7da
movq %rax, %rdi
callq 0x31f0
movq (%r15), %rcx
movss (%rcx), %xmm0
movq %rax, %rdi
callq 0x3170
leaq 0x4caa(%rip), %rsi      # 0xd087
movq %rax, %rdi
callq 0x31f0
movq (%r15), %rcx
movss 0x4(%rcx), %xmm0
movq %rax, %rdi
callq 0x3170
leaq 0x53cd(%rip), %rsi      # 0xd7c9
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x30d0
addq $0xc8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9466
leaq -0x50(%rbp), %rdi
callq 0x9cd8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x844b
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4b24
leaq -0x50(%rbp), %rdi
callq 0x9cd8
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/voronoi.cpp
// Function: CircleQueue::erase(Intersection const&, Intersection const&)
void erase(const Intersection& left_int, const Intersection& right_int)
    {
        CircleEvent dummy;
        const Point* ptA = left_int.pt_left;
        const Point* ptB = left_int.pt_right;
        const Point* ptC = right_int.pt_right;
        assert(ptB != nullptr);

        // no event to erase since one of the "intersections" is the null
        // intersection
        if(ptA == nullptr || ptC == nullptr)
            return;

        dummy.circle = solveCircle(*ptA, *ptB, *ptC);
        float end_y = dummy.circle.center.y - dummy.circle.radius;

        for(auto it = m_queue.lower_bound(dummy); it != m_queue.end() &&
                !(it->circle.center.y - it->circle.radius < end_y); ++it) {
            if(left_int.pt_left == it->left_int.pt_left &&
                    left_int.pt_right == it->left_int.pt_right &&
                    right_int.pt_left == it->right_int.pt_left &&
                    right_int.pt_right == it->right_int.pt_right) {
                it = m_queue.erase(it);
                break;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x9012
movq %rdx, %r14
movq (%r15), %rdi
movq 0x8(%rdx), %rdx
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x8f8b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6309
leaq -0x70(%rbp), %rsi
movlps %xmm0, 0x20(%rsi)
movss %xmm1, 0x28(%rsi)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
subss %xmm1, %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x967e
leaq 0x8(%rbx), %r12
movq (%r15), %r13
movq 0x8(%r15), %r15
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r12, %rax
je 0x8f7c
movss 0x44(%rax), %xmm0
subss 0x48(%rax), %xmm0
movaps -0x40(%rbp), %xmm1
ucomiss %xmm0, %xmm1
ja 0x8f7c
cmpq 0x20(%rax), %r13
jne 0x8ff7
cmpq 0x28(%rax), %r15
jne 0x8ff7
cmpq 0x30(%rax), %rbx
jne 0x8ff7
cmpq 0x38(%rax), %r14
je 0x9001
movq %rax, %rdi
callq 0x3230
jmp 0x8fc7
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x96ca
jmp 0x8f7c
leaq 0x4c04(%rip), %rdi      # 0xdc1d
leaq 0x42ea(%rip), %rsi      # 0xd30a
leaq 0x4c05(%rip), %rcx      # 0xdc2c
movl $0x125, %edx            # imm = 0x125
callq 0x3130
nop
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/./debug.h
// Function: void draw_state<std::set<Intersection, BeachCompare, std::allocator<Intersection>>, CircleQueue>(std::set<Intersection, BeachCompare, std::allocator<Intersection>> const&, CircleQueue const&, double, double)
void draw_state(const IntersectionContainer& intersections,
        const EventContainer& events, double start_sweep_y, double stop_sweep_y)
{
    if(std::isnan(start_sweep_y) || std::isnan(stop_sweep_y))
        return;

    for(double y = start_sweep_y; y > stop_sweep_y; y--)
        draw_state(intersections, events, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, -0x20(%rbp)
ucomisd %xmm1, %xmm0
jp 0x9400
movq %rsi, %rbx
movq %rdi, %r14
ucomisd -0x20(%rbp), %xmm0
jbe 0x9400
movq %r14, %rdi
movq %rbx, %rsi
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0xa463
movsd -0x18(%rbp), %xmm0
addsd 0x3e72(%rip), %xmm0     # 0xd270
jmp 0x93d5
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/./simple_svg.hpp
// Function: svg::Polyline::toString[abi:cxx11](svg::Layout const&) const
std::string toString(Layout const & layout) const
        {
            std::stringstream ss;
            ss << elemStart("polyline");

            ss << "points=\"";
            for (unsigned i = 0; i < points.size(); ++i)
                ss << translateX(points[i].x, layout) << "," << translateY(points[i].y, layout) << " ";
            ss << "\" ";

            ss << fill.toString(layout) << stroke.toString(layout) << emptyElemEnd();
            return ss.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x3160
leaq 0x28bc(%rip), %rsi      # 0xdd07
leaq -0x50(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x3090
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8a85
leaq -0x208(%rbp), %rbx
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x31d0
leaq -0x70(%rbp), %rdi
callq 0x30c0
leaq -0x50(%rbp), %rdi
callq 0x30c0
leaq 0x287c(%rip), %rsi      # 0xdd10
movq %rbx, %rdi
callq 0x31f0
xorl %ebx, %ebx
movl %ebx, %ebx
movq 0x58(%r15), %rax
movq 0x60(%r15), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rbx, %rcx
jbe 0xb515
movq %rbx, %r13
shlq $0x4, %r13
movsd (%rax,%r13), %xmm0
movq %r14, %rdi
callq 0x8ae4
leaq -0x208(%rbp), %rdi
callq 0x3300
movq %rax, %rdi
leaq 0x1bc7(%rip), %rsi      # 0xd0a6
callq 0x31f0
movq %rax, %r12
movq 0x58(%r15), %rax
movsd 0x8(%rax,%r13), %xmm0
movq %r14, %rdi
callq 0x8b17
movq %r12, %rdi
callq 0x3300
movq %rax, %rdi
leaq 0x1c3c(%rip), %rsi      # 0xd148
callq 0x31f0
incl %ebx
jmp 0xb49e
leaq 0x1c2b(%rip), %rsi      # 0xd147
leaq -0x208(%rbp), %rbx
movq %rbx, %rdi
callq 0x31f0
leaq 0x8(%r15), %rsi
leaq -0x70(%rbp), %rdi
movq %r14, %rdx
callq 0x3d90
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rbx
addq $0x28, %r15
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x405e
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x8baa
leaq -0x90(%rbp), %rsi
movq %rbx, %rdi
callq 0x31d0
leaq -0x90(%rbp), %rdi
callq 0x30c0
leaq -0x50(%rbp), %rdi
callq 0x30c0
leaq -0x70(%rbp), %rdi
callq 0x30c0
leaq -0x200(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x32f0
leaq -0x218(%rbp), %rdi
callq 0x3180
movq -0x30(%rbp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x30c0
jmp 0xb5ed
jmp 0xb5ea
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30c0
jmp 0xb5fd
jmp 0xb5fa
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0xb61a
jmp 0xb625
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x30c0
jmp 0xb616
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30c0
jmp 0xb628
jmp 0xb625
jmp 0xb625
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x3180
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/BrianYi[P]timer/src/main.cpp
// Function: main
int main()
{
    TimeDriver* timeDriver = new TimeDriver(1);
    AdvanceTimeWheel* advTimeWheel = new AdvanceTimeWheel;
    SecTimer* secTimer1 = new SecTimer(5);    
    SecTimer* secTimer2 = new SecTimer(10);
    SecTimer* secTimer3 = new SecTimer(60);
    MinTimer* minTimer1 = new MinTimer(1); 
    advTimeWheel->addTimer(secTimer1);
    advTimeWheel->addTimer(secTimer2);
    advTimeWheel->addTimer(secTimer3);
    advTimeWheel->addTimer(minTimer1);
    timeDriver->mountTimeWheel(advTimeWheel);
    timeDriver->start();
    delete timeDriver;
    delete advTimeWheel;
    delete secTimer1;
    delete secTimer2;
    delete secTimer3;
    delete minTimer1;
    exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x28
popq %rdi
callq 0x1090
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x1598
pushq $0x78
popq %rdi
callq 0x1090
movq %rax, %r14
movq %rax, %rdi
callq 0x15b0
pushq $0x20
popq %rdi
callq 0x1090
movq %rax, %r15
leaq 0x4(%rsp), %rsi
movl $0x5, (%rsi)
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x1658
pushq $0x20
popq %rdi
callq 0x1090
movq %rax, %r12
leaq 0x4(%rsp), %rsi
movl $0xa, (%rsi)
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x1658
pushq $0x20
popq %rdi
callq 0x1090
movq %rax, %r13
leaq 0x4(%rsp), %rsi
movl $0x3c, (%rsi)
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x1658
pushq $0x20
popq %rdi
callq 0x1090
movq %rax, %rbp
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x1678
movq %r14, %rdi
movq %r15, %rsi
callq 0x1698
movq %r14, %rdi
movq %r12, %rsi
callq 0x1698
movq %r14, %rdi
movq %r13, %rsi
callq 0x1698
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1698
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1236
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x8(%rax)
xorl %edi, %edi
callq 0x10b0
movq %rbp, %rdi
movq %rax, %rbp
pushq $0x20
popq %rsi
jmp 0x158b
movq %rax, %rbp
pushq $0x20
popq %rsi
movq %r13, %rdi
jmp 0x158b
movq %rax, %rbp
pushq $0x20
popq %rsi
movq %r12, %rdi
jmp 0x158b
movq %rax, %rbp
pushq $0x20
popq %rsi
movq %r15, %rdi
jmp 0x158b
movq %rax, %rbp
pushq $0x78
popq %rsi
movq %r14, %rdi
jmp 0x158b
movq %rax, %rbp
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x10a0
movq %rbp, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/BrianYi[P]timer/src/AdvanceTimeWheel.h
// Function: AdvanceTimeWheel::AdvanceTimeWheel()
AdvanceTimeWheel()
    {
        fMilliSec = 0;
        fSecWheelSize = 60;
        fSecFreq = 1000;
        fSecPtr = 0;
        fMinWheelSize = 60;
        fMinPtr = 0;
        fHourWheelSize = 24;
        fHourPtr = 0;
        fTotalTimerNum = 0;
        fSecWheel.resize(fSecWheelSize);
        fMinWheel.resize(fMinWheelSize);
        fHourWheel.resize(fHourWheelSize);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x4756(%rip), %rax      # 0x5d18
movq %rax, (%rdi)
leaq 0x30(%rdi), %rbx
leaq 0x48(%rdi), %r14
leaq 0x60(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
andq $0x0, 0x70(%rdi)
movaps 0x1a80(%rip), %xmm0     # 0x3070
movups %xmm0, 0x8(%rdi)
movaps 0x1a85(%rip), %xmm0     # 0x3080
movups %xmm0, 0x18(%rdi)
xorl %eax, %eax
xchgl %eax, 0x28(%rdi)
pushq $0x3c
popq %rsi
movq %rbx, %rdi
callq 0x183a
movslq 0x18(%r12), %rsi
movq %r14, %rdi
callq 0x183a
movslq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x183a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x1870
movq %r14, %rdi
callq 0x1870
movq %rbx, %rdi
callq 0x1870
movq %r12, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/BrianYi[P]timer/src/AdvanceTimeWheel.h
// Function: AdvanceTimeWheel::addTimer(TimerInterface*)
void addTimer(TimerInterface* timer)
    {
        int timespan = timer->getTimeSpan();
        int passedSec = timespan / fSecFreq;
        ListNode *node = new ListNode;
        node->timer = timer;
        node->sec = fSecPtr + passedSec;
        node->min = fMinPtr + node->sec / fSecWheelSize;
        node->hour = fHourPtr + node->min / fMinWheelSize;
        node->sec %= fSecWheelSize;
        node->min %= fMinWheelSize;
        node->hour %= fHourWheelSize;
        if (node->hour > fHourPtr)
            fHourWheel[node->hour].push(node);
        else if (node->min > fMinPtr)
            fMinWheel[node->min].push(node);
        else if (node->sec > fSecPtr)
            fSecWheel[node->sec].push(node);
        else
            printf("error: %d:%s\r\n", __LINE__, __FUNCTION__);
        
        fTotalTimerNum++;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1406
cltd
idivl 0xc(%rbx)
movl %eax, %ebp
pushq $0x18
popq %rdi
callq 0x1090
movq %rax, %rsi
movq %rax, 0x8(%rsp)
movq %r14, (%rax)
movl 0x14(%rbx), %r8d
movl 0x1c(%rbx), %r9d
addl %r8d, %ebp
movl %ebp, %eax
cltd
idivl 0x10(%rbx)
movl %edx, %ecx
addl %r9d, %eax
movl 0x24(%rbx), %r10d
cltd
idivl 0x18(%rbx)
movl %edx, %edi
addl %r10d, %eax
movl %ecx, 0x10(%rsi)
movl %edx, 0xc(%rsi)
cltd
idivl 0x20(%rbx)
movl %edx, 0x8(%rsi)
cmpl %r10d, %edx
jle 0x1709
movslq %edx, %rax
imulq $0x50, %rax, %rdi
addq 0x60(%rbx), %rdi
jmp 0x172b
cmpl %r9d, %edi
jle 0x171b
movslq %edi, %rax
imulq $0x50, %rax, %rdi
addq 0x48(%rbx), %rdi
jmp 0x172b
cmpl %r8d, %ecx
jle 0x1742
movslq %ecx, %rax
imulq $0x50, %rax, %rdi
addq 0x30(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x253e
lock
incl 0x28(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a13(%rip), %rdi      # 0x315c
leaq 0x1a1b(%rip), %rdx      # 0x316b
pushq $0x5e
popq %rsi
xorl %eax, %eax
callq 0x1030
jmp 0x1735
// File: /workspace/github_cpp_makefile_star2_O2/BrianYi[P]timer/src/TimeDriver.h
// Function: TimeDriver::start()
void start()
    {
        struct timeval tv;
        gettimeofday(&tv, NULL);
        int64_t curMicrosecTMS = tv.tv_sec * 1000000 + tv.tv_usec;
        int64_t nextMicrosecTMS = curMicrosecTMS + fGranularity * 1000;
        while (true)
        {
            gettimeofday(&tv, NULL);
            curMicrosecTMS = tv.tv_sec * 1000000 + tv.tv_usec;
            if (nextMicrosecTMS - curMicrosecTMS > 0)
                usleep(nextMicrosecTMS - curMicrosecTMS);
            for (auto& timeWheelPtr : fTimeWheelArry)
                timeWheelPtr->run(fGranularity);
            nextMicrosecTMS = curMicrosecTMS + fGranularity * 1000;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x10e0
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
movslq 0x20(%rbx), %rcx
imulq $0x3e8, %rcx, %r15      # imm = 0x3E8
addq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x10e0
imulq $0xf4240, (%rsp), %r12  # imm = 0xF4240
addq 0x8(%rsp), %r12
subq %r12, %r15
jle 0x17b6
movl %r15d, %edi
callq 0x10c0
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r13
cmpq %r13, %r15
je 0x17d5
movq (%r15), %rdi
movl 0x20(%rbx), %esi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r15
jmp 0x17be
movslq 0x20(%rbx), %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
addq %rax, %r12
movq %r12, %r15
jmp 0x1792
// File: /workspace/github_cpp_makefile_star2_O2/ruippeixotog[P]algo-lib/simulated-annealing.cpp
// Function: main
int main() {
  srand(time(NULL));

  Sol sol;
  for(int i = 0; i < N; i++) sol.order[i] = i;
  random_shuffle(sol.order, sol.order + N);
  sol.updateScore();

  double avgDist = 0.0;
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++)
      if (i != j) avgDist += dist[i][j];
  }
  avgDist /= N * (N - 1);

  double maxt = avgDist * 10.0;
  double mint = avgDist * 0.001;
  simulatedAnnealing<Sol, Mut>(sol, maxt, mint, TIMELIMIT);

  printf("%d\n", sol.total);
  return 0;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1050
movl %eax, %edi
callq 0x1060
cmpq $0xf, %rbx
je 0x120e
movl %ebx, (%rsp,%rbx,4)
incq %rbx
jmp 0x1200
leaq 0x3c(%rsp), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x12a5
movq %rbx, %rdi
callq 0x1302
xorpd %xmm1, %xmm1
leaq 0x2e3f(%rip), %rax      # 0x4070
xorl %ecx, %ecx
cmpq $0xf, %rcx
je 0x125d
xorl %edx, %edx
cmpq $0xf, %rdx
je 0x1254
cmpq %rdx, %rcx
je 0x124f
cvtsi2sdl (%rax,%rdx,4), %xmm0
addsd %xmm0, %xmm1
incq %rdx
jmp 0x123b
incq %rcx
addq $0x3c, %rax
jmp 0x1233
divsd 0xdab(%rip), %xmm1      # 0x2010
movsd 0xdab(%rip), %xmm0      # 0x2018
mulsd %xmm1, %xmm0
mulsd 0xda7(%rip), %xmm1      # 0x2020
movq %rsp, %rbx
movsd 0xda4(%rip), %xmm2      # 0x2028
movq %rbx, %rdi
callq 0x133e
movl 0x3c(%rbx), %esi
leaq 0xdba(%rip), %rdi       # 0x2050
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ruippeixotog[P]algo-lib/simulated-annealing.cpp
// Function: Mut::init(Sol&)
void init(Sol& sol) {
    total = dist[sol.order[(i + 1) % N]][sol.order[i]] -
        dist[sol.order[i]][sol.order[(i + 1) % N]];

    total += dist[sol.order[(i - 1 + N) % N]][sol.order[(i + 1) % N]] -
        dist[sol.order[(i - 1 + N) % N]][sol.order[i]];

    total += dist[sol.order[i]][sol.order[(i + 2) % N]] -
        dist[sol.order[(i + 1) % N]][sol.order[(i + 2) % N]];
  }

// Assembly:
pushq %rbx
movslq (%rdi), %r9
leal 0x1(%r9), %eax
movl $0xf, %r10d
cltd
idivl %r10d
movslq %edx, %r8
movslq (%rsi,%r8,4), %rax
movslq (%rsi,%r9,4), %rdx
imulq $0x3c, %rax, %r11
leaq 0x2ad4(%rip), %rcx      # 0x4070
addq %rcx, %r11
movl (%r11,%rdx,4), %r11d
imulq $0x3c, %rdx, %rdx
addq %rcx, %rdx
subl (%rdx,%rax,4), %r11d
movl %r11d, 0x4(%rdi)
leal 0xe(%r9), %eax
cltd
idivl %r10d
movslq %edx, %rax
movslq (%rsi,%rax,4), %rax
movslq (%rsi,%r8,4), %rdx
imulq $0x3c, %rax, %rax
addq %rcx, %rax
movl (%rax,%rdx,4), %ebx
movslq (%rsi,%r9,4), %rdx
subl (%rax,%rdx,4), %ebx
addl %r11d, %ebx
movl %ebx, 0x4(%rdi)
movslq (%rsi,%r9,4), %r11
leal 0x2(%r9), %eax
cltd
idivl %r10d
movslq %edx, %rax
movslq (%rsi,%rax,4), %rax
imulq $0x3c, %r11, %rdx
addq %rcx, %rdx
movslq (%rsi,%r8,4), %rsi
imulq $0x3c, %rsi, %rsi
addl (%rdx,%rax,4), %ebx
addq %rcx, %rsi
subl (%rsi,%rax,4), %ebx
movl %ebx, 0x4(%rdi)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ruippeixotog[P]algo-lib/simulated-annealing.cpp
// Function: Mut::apply(Sol&)
void apply(Sol& sol) {
    int tmp = sol.order[i];
    sol.order[i] = sol.order[(i + 1) % N];
    sol.order[(i + 1) % N] = tmp;

    sol.total += total;
  }

// Assembly:
movslq (%rdi), %rcx
movl (%rsi,%rcx,4), %r8d
leal 0x1(%rcx), %eax
pushq $0xf
popq %r9
cltd
idivl %r9d
movslq %edx, %rax
movl (%rsi,%rax,4), %eax
movl %eax, (%rsi,%rcx,4)
movl (%rdi), %eax
incl %eax
cltd
idivl %r9d
movslq %edx, %rax
movl %r8d, (%rsi,%rax,4)
movl 0x4(%rdi), %eax
addl %eax, 0x3c(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/main.cpp
// Function: init_table()
int init_table()
{
	int custom_len=strlen(custom_str);
	for(int i=0;i<custom_len;i++)
	{
		unsigned char c= custom_str[i];
		char_table[c]=1;
	}
	return 0;
}

// Assembly:
pushq %rbx
leaq 0x10e550(%rip), %rbx    # 0x5108d0
movq %rbx, %rdi
callq 0x4010d8
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
leaq 0x112c4a(%rip), %rdx    # 0x514fe0
cmpq %rcx, %rax
je 0x4023a8
movzbl (%rcx,%rbx), %esi
movb $0x1, (%rsi,%rdx)
incq %rcx
jmp 0x402396
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5_update(md5_context*, unsigned char const*, unsigned long)
void md5_update( md5_context *ctx, const unsigned char *input, size_t ilen )
{
    size_t fill;
    uint32_t left;

    if( ilen == 0 )
        return;

    left = ctx->total[0] & 0x3F;
    fill = 64 - left;

    ctx->total[0] += (uint32_t) ilen;
    ctx->total[0] &= 0xFFFFFFFF;

    if( ctx->total[0] < (uint32_t) ilen )
        ctx->total[1]++;

    if( left && ilen >= fill )
    {
        memcpy( (void *) (ctx->buffer + left), input, fill );
        md5_process( ctx, ctx->buffer );
        input += fill;
        ilen  -= fill;
        left = 0;
    }

    while( ilen >= 64 )
    {
        md5_process( ctx, input );
        input += 64;
        ilen  -= 64;
    }

    if( ilen > 0 )
    {
        memcpy( (void *) (ctx->buffer + left), input, ilen );
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x402f88
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %eax
andl $0x3f, %eax
movl %edx, %esi
addl %ecx, %esi
movl %esi, (%rdi)
jae 0x402efd
incl 0x4(%r14)
xorl %ebp, %ebp
testl %eax, %eax
je 0x402f19
pushq $0x40
popq %r12
subq %rax, %r12
movq %rdx, %r15
subq %r12, %r15
jae 0x402f1e
movq %rdx, %r15
movl %eax, %ebp
jmp 0x402f5a
movq %rdx, %r15
jmp 0x402f5a
leaq 0x18(%r14), %r13
movl %eax, %eax
leaq (%r14,%rax), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x401040
movq %r14, %rdi
movq %r13, %rsi
callq 0x40271b
addq %r12, %rbx
jmp 0x402f5a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40271b
addq $0x40, %rbx
addq $-0x40, %r15
cmpq $0x40, %r15
jae 0x402f47
testq %r15, %r15
je 0x402f88
movl %ebp, %eax
leaq (%r14,%rax), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x401040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5_finish(md5_context*, unsigned char*)
void md5_finish( md5_context *ctx, unsigned char output[16] )
{
    uint32_t last, padn;
    uint32_t high, low;
    unsigned char msglen[8];

    high = ( ctx->total[0] >> 29 )
         | ( ctx->total[1] <<  3 );
    low  = ( ctx->total[0] <<  3 );

    PUT_UINT32_LE( low,  msglen, 0 );
    PUT_UINT32_LE( high, msglen, 4 );

    last = ctx->total[0] & 0x3F;
    padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );

    md5_update( ctx, md5_padding, padn );
    md5_update( ctx, msglen, 8 );

    PUT_UINT32_LE( ctx->state[0], output,  0 );
    PUT_UINT32_LE( ctx->state[1], output,  4 );
    PUT_UINT32_LE( ctx->state[2], output,  8 );
    PUT_UINT32_LE( ctx->state[3], output, 12 );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
shldl $0x3, %eax, %ecx
leal (,%rax,8), %edx
leaq 0x8(%rsp), %r15
movb %dl, (%r15)
movl %eax, %edx
shrl $0x5, %edx
movb %dl, 0x1(%r15)
movl %eax, %edx
shrl $0xd, %edx
movb %dl, 0x2(%r15)
movl %eax, %edx
shrl $0x15, %edx
movb %dl, 0x3(%r15)
movb %cl, 0x4(%r15)
movb %ch, 0xd(%rsp)
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, 0x6(%r15)
shrl $0x18, %ecx
movb %cl, 0x7(%r15)
andl $0x3f, %eax
xorl %edx, %edx
cmpl $0x38, %eax
setae %dl
shll $0x6, %edx
orl $0x38, %edx
subl %eax, %edx
leaq 0xd1595(%rip), %rsi     # 0x4d45a0
callq 0x402ed0
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x402ed0
movb 0x8(%r14), %al
movb %al, (%rbx)
movb 0x9(%r14), %al
movb %al, 0x1(%rbx)
movb 0xa(%r14), %al
movb %al, 0x2(%rbx)
movb 0xb(%r14), %al
movb %al, 0x3(%rbx)
movb 0xc(%r14), %al
movb %al, 0x4(%rbx)
movb 0xd(%r14), %al
movb %al, 0x5(%rbx)
movb 0xe(%r14), %al
movb %al, 0x6(%rbx)
movb 0xf(%r14), %al
movb %al, 0x7(%rbx)
movb 0x10(%r14), %al
movb %al, 0x8(%rbx)
movb 0x11(%r14), %al
movb %al, 0x9(%rbx)
movb 0x12(%r14), %al
movb %al, 0xa(%rbx)
movb 0x13(%r14), %al
movb %al, 0xb(%rbx)
movb 0x14(%r14), %al
movb %al, 0xc(%rbx)
movb 0x15(%r14), %al
movb %al, 0xd(%rbx)
movb 0x16(%r14), %al
movb %al, 0xe(%rbx)
movb 0x17(%r14), %al
movb %al, 0xf(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5(unsigned char const*, unsigned long, unsigned char*)
void md5( const unsigned char *input, size_t ilen, unsigned char output[16] )
{
    /*static md5_context ctx;
    static int done=0;
    if(done==0)
    {
        md5_init( &ctx );
    	done=1;
    }*/
    md5_context ctx;
    md5_init( &ctx );
    md5_starts( &ctx );
    md5_update( &ctx, input, ilen );
    md5_finish( &ctx, output );
    md5_free( &ctx );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movl $0xd8, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x401098
movaps 0xd14a9(%rip), %xmm0    # 0x4d4570
movups %xmm0, 0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x402ed0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x402f97
movq %r12, %rdi
callq 0x4026e4
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5_hmac_starts(md5_context*, unsigned char const*, unsigned long)
void md5_hmac_starts( md5_context *ctx, const unsigned char *key,
                      size_t keylen )
{
    size_t i;
    unsigned char sum[16];

    if( keylen > 64 )
    {
        md5( key, keylen, sum );
        keylen = 16;
        key = sum;
    }

    memset( ctx->ipad, 0x36, 64 );
    memset( ctx->opad, 0x5C, 64 );

    for( i = 0; i < keylen; i++ )
    {
        ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
        ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
    }

    md5_starts( ctx );
    md5_update( ctx, ctx->ipad, 64 );

    polarssl_zeroize( sum, sizeof( sum ) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x41, %rdx
jb 0x40312a
movq %rsp, %r14
pushq $0x10
popq %r15
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x403097
movq %r14, %rsi
movq %r15, %rdx
leaq 0x58(%rbx), %rax
movaps 0xd144b(%rip), %xmm0    # 0x4d4580
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x58(%rbx)
movaps 0xd1441(%rip), %xmm0    # 0x4d4590
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0xa8(%rbx)
movups %xmm0, 0xb8(%rbx)
movups %xmm0, 0xc8(%rbx)
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x40318c
movb (%rsi,%rcx), %dil
xorb %dil, 0x58(%rbx,%rcx)
movb (%rsi,%rcx), %dil
xorb %dil, 0x98(%rbx,%rcx)
incq %rcx
jmp 0x40316d
movaps 0xd13cd(%rip), %xmm0    # 0x4d4560
movups %xmm0, (%rbx)
movabsq $0x1032547698badcfe, %rcx # imm = 0x1032547698BADCFE
movq %rcx, 0x10(%rbx)
pushq $0x40
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x402ed0
movq %rsp, %rdi
pushq $0x10
popq %rsi
callq 0x4026f1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5_hmac_finish(md5_context*, unsigned char*)
void md5_hmac_finish( md5_context *ctx, unsigned char output[16] )
{
    unsigned char tmpbuf[16];

    md5_finish( ctx, tmpbuf );
    md5_starts( ctx );
    md5_update( ctx, ctx->opad, 64 );
    md5_update( ctx, tmpbuf, 16 );
    md5_finish( ctx, output );

    polarssl_zeroize( tmpbuf, sizeof( tmpbuf ) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rsi
callq 0x402f97
movaps 0xd1371(%rip), %xmm0    # 0x4d4560
movups %xmm0, (%r14)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%r14)
leaq 0x98(%r14), %rsi
pushq $0x40
popq %rdx
movq %r14, %rdi
callq 0x402ed0
pushq $0x10
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x402ed0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x402f97
movq %r15, %rdi
movq %r12, %rsi
callq 0x4026f1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5_hmac(unsigned char const*, unsigned long, unsigned char const*, unsigned long, unsigned char*)
void md5_hmac( const unsigned char *key, size_t keylen,
               const unsigned char *input, size_t ilen,
               unsigned char output[16] )
{
    md5_context ctx;

    md5_init( &ctx );
    md5_hmac_starts( &ctx, key, keylen );
    md5_hmac_update( &ctx, input, ilen );
    md5_hmac_finish( &ctx, output );
    md5_free( &ctx );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsp, %rbp
movl $0xd8, %edx
movq %rbp, %rdi
xorl %esi, %esi
callq 0x401098
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4030fd
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x402ed0
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x4031cc
movq %rbp, %rdi
callq 0x4026e4
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/pbkdf2-sha1.cpp
// Function: sha1_update(sha1_context*, unsigned char const*, int)
void sha1_update(sha1_context * ctx, const unsigned char *input, int ilen)
{
	int fill;
	unsigned long left;

	if (ilen <= 0)
		return;

	left = ctx->total[0] & 0x3F;
	fill = 64 - left;

	ctx->total[0] += (unsigned long) ilen;
	ctx->total[0] &= 0xFFFFFFFF;

	if (ctx->total[0] < (unsigned long) ilen)
		ctx->total[1]++;

	if (left && ilen >= fill) {
		memcpy((void *) (ctx->buffer + left), (void *) input, fill);
		sha1_process(ctx, ctx->buffer);
		input += fill;
		ilen -= fill;
		left = 0;
	}

	while (ilen >= 64) {
		sha1_process(ctx, input);
		input += 64;
		ilen -= 64;
	}

	if (ilen > 0) {
		memcpy((void *) (ctx->buffer + left), (void *) input, ilen);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edx, %edx
jle 0x4033c6
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl %eax, %r12d
andl $0x3f, %r12d
movl %edx, %ecx
addl %edx, %eax
movq %rax, (%rdi)
cmpq %rcx, %rax
jae 0x403345
incq 0x8(%r14)
testq %r12, %r12
je 0x403385
pushq $0x40
popq %rax
subl %r12d, %eax
movl %edx, %ebp
subl %eax, %ebp
jb 0x403388
leaq 0x38(%r14), %r15
leaq (%r14,%r12), %rdi
addq $0x38, %rdi
movl %eax, %r12d
movq %rbx, %rsi
movq %r12, %rdx
callq 0x401040
movq %r14, %rdi
movq %r15, %rsi
callq 0x4033cf
addq %r12, %rbx
xorl %r12d, %r12d
movl %ebp, %edx
jmp 0x403388
xorl %r12d, %r12d
movl %edx, %r15d
cmpl $0x40, %r15d
jl 0x4033a6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4033cf
addq $0x40, %rbx
addq $-0x40, %r15
jmp 0x40338b
testl %r15d, %r15d
jle 0x4033c6
leaq (%r14,%r12), %rdi
addq $0x38, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x401040
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/pbkdf2-sha1.cpp
// Function: sha1(unsigned char const*, int, unsigned char*)
void sha1(const unsigned char *input, int ilen, unsigned char output[20])
{
	sha1_context ctx;

	sha1_starts(&ctx);
	sha1_update(&ctx, input, ilen);
	sha1_finish(&ctx, output);

}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x67452301, 0x10(%r14) # imm = 0x67452301
movl $0x98badcfe, %eax       # imm = 0x98BADCFE
leaq 0x5712ce8b(%rax), %rcx
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq $0x10325476, 0x28(%r14) # imm = 0x10325476
addq $0x2b1804f2, %rax       # imm = 0x2B1804F2
movq %rax, 0x30(%r14)
movq %r14, %rdi
callq 0x403315
movq %r14, %rdi
movq %rbx, %rsi
callq 0x404f70
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/pbkdf2-sha1.cpp
// Function: sha1_hmac_starts(sha1_context*, unsigned char const*, int)
void sha1_hmac_starts(sha1_context * ctx, const unsigned char *key, int keylen)
{
	int i;
	unsigned char sum[20];

	if (keylen > 64) {
		sha1(key, keylen, sum);
		keylen = 20;
		key = sum;
	}

	memset(ctx->ipad, 0x36, 64);
	memset(ctx->opad, 0x5C, 64);

	for (i = 0; i < keylen; i++) {
		ctx->ipad[i] = (unsigned char) (ctx->ipad[i] ^ key[i]);
		ctx->opad[i] = (unsigned char) (ctx->opad[i] ^ key[i]);
	}

	sha1_starts(ctx);
	sha1_update(ctx, ctx->ipad, 64);

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x41, %edx
jl 0x405128
movq %rsp, %r14
movq %rsi, %rdi
movl %edx, %esi
movq %r14, %rdx
callq 0x40509b
pushq $0x14
popq %rdx
movq %r14, %rsi
leaq 0x78(%rbx), %rax
movaps 0xcf44d(%rip), %xmm0    # 0x4d4580
movups %xmm0, 0xa8(%rbx)
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movaps 0xcf43d(%rip), %xmm0    # 0x4d4590
movups %xmm0, 0xb8(%rbx)
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xe8(%rbx)
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
cmpq %rcx, %rdx
je 0x405195
movb (%rsi,%rcx), %dil
xorb %dil, 0x78(%rbx,%rcx)
movb (%rsi,%rcx), %dil
xorb %dil, 0xb8(%rbx,%rcx)
incq %rcx
jmp 0x405176
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x67452301, 0x10(%rbx) # imm = 0x67452301
movl $0x98badcfe, %ecx       # imm = 0x98BADCFE
leaq 0x5712ce8b(%rcx), %rdx
movq %rdx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq $0x10325476, 0x28(%rbx) # imm = 0x10325476
addq $0x2b1804f2, %rcx       # imm = 0x2B1804F2
movq %rcx, 0x30(%rbx)
pushq $0x40
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x403315
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/pbkdf2-sha1.cpp
// Function: sha1_hmac_finish(sha1_context*, unsigned char*)
void sha1_hmac_finish(sha1_context * ctx, unsigned char output[20])
{
	unsigned char tmpbuf[20];

	sha1_finish(ctx, tmpbuf);
	sha1_starts(ctx);
	sha1_update(ctx, ctx->opad, 64);
	sha1_update(ctx, tmpbuf, 20);
	sha1_finish(ctx, output);

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rsi
callq 0x404f70
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x67452301, 0x10(%r14) # imm = 0x67452301
movl $0x98badcfe, %eax       # imm = 0x98BADCFE
leaq 0x5712ce8b(%rax), %rcx
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq $0x10325476, 0x28(%r14) # imm = 0x10325476
addq $0x2b1804f2, %rax       # imm = 0x2B1804F2
movq %rax, 0x30(%r14)
leaq 0xb8(%r14), %rsi
pushq $0x40
popq %rdx
movq %r14, %rdi
callq 0x403315
pushq $0x14
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x403315
movq %r14, %rdi
movq %rbx, %rsi
callq 0x404f70
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/pbkdf2-sha256.cpp
// Function: sha2_update(sha2_context*, unsigned char const*, unsigned long)
void sha2_update( sha2_context *ctx, const unsigned char *input, size_t ilen )
{
    size_t fill;
    unsigned long left;

    if( ilen <= 0 )
        return;

    left = ctx->total[0] & 0x3F;
    fill = 64 - left;

    ctx->total[0] += (unsigned long) ilen;
    ctx->total[0] &= 0xFFFFFFFF;

    if( ctx->total[0] < (unsigned long) ilen )
        ctx->total[1]++;

    if( left && ilen >= fill )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, fill );
        sha2_process( ctx, ctx->buffer );
        input += fill;
        ilen  -= fill;
        left = 0;
    }

    while( ilen >= 64 )
    {
        sha2_process( ctx, input );
        input += 64;
        ilen  -= 64;
    }

    if( ilen > 0 )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, ilen );
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x405588
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r13
leal (%rdx,%r13), %eax
andl $0x3f, %r13d
movq %rax, (%rdi)
cmpq %rdx, %rax
jae 0x405503
incq 0x8(%r14)
testq %r13, %r13
je 0x405544
pushq $0x40
popq %r12
subq %r13, %r12
movq %r15, %rbp
subq %r12, %rbp
jb 0x40555c
leaq 0x50(%r14), %r15
leaq (%r14,%r13), %rdi
addq $0x50, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x401040
movq %r14, %rdi
movq %r15, %rsi
callq 0x405597
addq %r12, %rbx
xorl %r13d, %r13d
movq %rbp, %r15
jmp 0x40555c
xorl %r13d, %r13d
jmp 0x40555c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x405597
addq $0x40, %rbx
addq $-0x40, %r15
cmpq $0x40, %r15
jae 0x405549
testq %r15, %r15
je 0x405588
leaq (%r14,%r13), %rdi
addq $0x50, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x401040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/pbkdf2-sha256.cpp
// Function: sha2(unsigned char const*, unsigned long, unsigned char*, int)
void sha2( const unsigned char *input, size_t ilen,
           unsigned char output[32], int is224 )
{
    sha2_context ctx;

    sha2_starts( &ctx, is224 );
    sha2_update( &ctx, input, ilen );
    sha2_finish( &ctx, output );

    memset( &ctx, 0, sizeof( sha2_context ) );
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
testl %ecx, %ecx
je 0x409d57
movaps 0xca920(%rip), %xmm0    # 0x4d4660
movaps 0xca929(%rip), %xmm1    # 0x4d4670
movaps 0xca932(%rip), %xmm2    # 0x4d4680
movaps 0xca93b(%rip), %xmm3    # 0x4d4690
jmp 0x409d73
movaps 0xca8c2(%rip), %xmm0    # 0x4d4620
movaps 0xca8cb(%rip), %xmm1    # 0x4d4630
movaps 0xca8d4(%rip), %xmm2    # 0x4d4640
movaps 0xca8dd(%rip), %xmm3    # 0x4d4650
movq %rsp, %r14
movaps %xmm3, 0x10(%r14)
movaps %xmm2, 0x20(%r14)
movaps %xmm1, 0x30(%r14)
movaps %xmm0, 0x40(%r14)
movl %ecx, 0x110(%r14)
movq %r14, %rdi
callq 0x4054cf
movq %r14, %rdi
movq %rbx, %rsi
callq 0x409b90
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq