LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/EduBic[P]TSP-MetaheuristicSolvers/./TSPSolution.h
// Function: TSPSolution::TSPSolution(TSP const&)
TSPSolution( const TSP& tsp ) {

        sequence.reserve(tsp.n + 1);

        for ( int i = 0; i < tsp.n ; ++i ) {
            sequence.push_back(i);
        }

        sequence.push_back(0);

        solveBy = "Random";
        userTime = -1.0;
        cpuTime = -1.0;
        iterations = 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %r13
movq %r13, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movslq (%rsi), %rsi
incq %rsi
callq 0x5768
movl $0x0, 0x8(%rsp)
cmpl $0x0, (%r15)
jle 0x50a5
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x508b
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5096
movq %rbx, %rdi
movq %r12, %rdx
callq 0x5816
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
cmpl (%r15), %eax
jl 0x5075
movl $0x0, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x50c7
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x50d4
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x592e
movq 0x20(%rbx), %rdx
leaq 0x315f(%rip), %rcx      # 0x823e
movl $0x6, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x3360
movaps 0x2f1a(%rip), %xmm0     # 0x8010
movups %xmm0, 0x38(%rbx)
movl $0x0, 0x48(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5113
jmp 0x5113
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x5123
callq 0x3290
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5130
callq 0x3290
movq %r15, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/EduBic[P]TSP-MetaheuristicSolvers/./TSPSolution.h
// Function: TSPSolution::initRandom(int)
void initRandom(int seed = 42) {
        srand(seed/*time(NULL)*/);

        for (uint i = 1 ; i < sequence.size() ; ++i ) {
            // initial and final position are fixed (initial/final node remains 0)

            int idx1 = rand() % (sequence.size()-2) + 1;
            int idx2 = rand() % (sequence.size()-2) + 1;

            int tmp = sequence[idx1];
            sequence[idx1] = sequence[idx2];
            sequence[idx2] = tmp;
        }

        std::cout << "###" << std::endl;
        print(std::cout);
        std::cout << "###" << std::endl;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %edi
callq 0x32a0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x5, %rax
jb 0x51ce
movl $0x2, %ebp
movabsq $0x100000000, %r15      # imm = 0x100000000
callq 0x30c0
cltq
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x2, %rcx
addq $-0x2, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %r14
callq 0x30c0
cltq
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
subq %rsi, %rcx
sarq $0x2, %rcx
leaq -0x2(%rcx), %rdi
xorl %edx, %edx
divq %rdi
shlq $0x20, %r14
addq %r15, %r14
sarq $0x1e, %r14
movl (%rsi,%r14), %eax
shlq $0x20, %rdx
addq %r15, %rdx
sarq $0x1e, %rdx
movl (%rsi,%rdx), %edi
movl %edi, (%rsi,%r14)
movl %eax, (%rsi,%rdx)
movl %ebp, %eax
incl %ebp
cmpq %rax, %rcx
ja 0x5165
movq 0x5dfb(%rip), %r14      # 0xafd0
leaq 0x3069(%rip), %r15      # 0x8245
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a02
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O3/EduBic[P]TSP-MetaheuristicSolvers/./TSPSolution.h
// Function: TSPSolution::evaluateObjectiveFunction(TSP const&) const
double evaluateObjectiveFunction(const TSP& tsp ) const {
        double total = 0.0;

        for ( uint i = 0 ; i < sequence.size() - 1 ; ++i ) {
            int from = sequence[i]  ;
            int to   = sequence[i+1];
            total += tsp.cost[from][to];
        }

        return total;
    }

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
decq %rcx
je 0x5325
movq 0x8(%rsi), %rdx
movl (%rax), %edi
xorpd %xmm0, %xmm0
movl $0x1, %esi
movl %esi, %r8d
movslq %edi, %rdi
movslq (%rax,%r8,4), %r9
leaq (%rdi,%rdi,2), %rdi
movq (%rdx,%rdi,8), %rdi
addsd (%rdi,%r9,8), %xmm0
incl %esi
movl %r9d, %edi
cmpq %r8, %rcx
ja 0x5302
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/EduBic[P]TSP-MetaheuristicSolvers/./TSPSolution.h
// Function: TSPSolution::print(std::ostream&) const
void print(std::ostream& out) const {
        out << std::endl;
        for (uint i = 0; i < sequence.size(); i++ ) {
            out << sequence[i] << " ";
        }
        out << std::endl;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq -0x18(%rax), %rdi
addq %rsi, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31f0
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x5a7f
movl $0x1, %ebp
xorl %ecx, %ecx
leaq 0x26d8(%rip), %r15      # 0x8125
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
callq 0x3400
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x32f0
movl %ebp, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x5a4d
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O3/EduBic[P]TSP-MetaheuristicSolvers/LocalSearchSolver.cpp
// Function: LocalSearchSolver::swap(TSPSolution&, move const&)
TSPSolution& LocalSearchSolver::swap( TSPSolution& tspSol , const TSPMove& move ) {

    TSPSolution tmpSol(tspSol);

    for (int i = move.from ; i <= move.to ; ++i) {
        tspSol.sequence[i] = tmpSol.sequence[move.to-(i-move.from)];
    }

    return tspSol;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61ec
movslq (%r14), %rax
movl 0x4(%r14), %ecx
cmpl %ecx, %eax
jg 0x61bf
movq 0x8(%rsp), %rdx
movq (%rbx), %rsi
movq %rax, %rdi
decq %rdi
negl %eax
addl (%r14), %ecx
addl %eax, %ecx
movslq %ecx, %rcx
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x4(%rsi,%rdi,4)
movslq 0x4(%r14), %rcx
incq %rdi
decl %eax
cmpq %rcx, %rdi
jl 0x61a2
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61d2
callq 0x3290
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x61e1
callq 0x3290
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/EduBic[P]TSP-MetaheuristicSolvers/./TSPSolution.h
// Function: TSPSolution::TSPSolution(TSPSolution const&)
TSPSolution( const TSPSolution& tspSol ) {
        sequence.reserve(tspSol.sequence.size());

        for (uint i = 0; i < tspSol.sequence.size(); ++i ) {
            sequence.push_back(tspSol.sequence[i]);
        }

        solveBy = tspSol.solveBy;
        userTime = tspSol.userTime;
        cpuTime = tspSol.cpuTime;
        iterations = tspSol.iterations;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %r12
movq %r12, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x2, %rsi
callq 0x5768
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x6275
movl $0x1, %ebp
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6256
movl (%rdx), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6261
movq %rbx, %rdi
callq 0x5816
movq (%r15), %rax
movl %ebp, %ecx
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x623a
leaq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x3180
movups 0x38(%r15), %xmm0
movups %xmm0, 0x38(%rbx)
movl 0x48(%r15), %eax
movl %eax, 0x48(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x629c
movq %rax, %r15
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x62ac
callq 0x3290
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x62b9
callq 0x3290
movq %r15, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O3/EduBic[P]TSP-MetaheuristicSolvers/TabuSearchSolver.cpp
// Function: TabuSearchSolver::getSolverName[abi:cxx11]() const
std::string TabuSearchSolver::getSolverName() const {
    char buffer[50];
    sprintf(buffer, "\tTenure: %d, MaxIter: %d", mTabuLength, mMaxIteration);

    std::string tmp = std::string(buffer);

    if (ACmode) {
        if (BestImprovement) {
            return "Tabu Search AC - BI " + tmp;
        } else {
            return "Tabu Search AC - FI " + tmp;
        }
    } else {
        if (BestImprovement) {
            return "Tabu Search - BI " + tmp;
        } else {
            return "Tabu Search - FI " + tmp;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %edx
movl 0xc(%rsi), %ecx
leaq 0x1fcc(%rip), %rsi      # 0x82e0
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3080
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r15, %rdi
callq 0x3140
leaq (%rsp,%rax), %rdx
addq $0x20, %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5d1c
leaq 0x1fd2(%rip), %rax      # 0x8323
leaq 0x1fdd(%rip), %rcx      # 0x8335
cmpb $0x0, 0x81(%r14)
cmovneq %rax, %rcx
leaq 0x1f8e(%rip), %rax      # 0x82f9
leaq 0x1f9c(%rip), %rsi      # 0x830e
cmovneq %rax, %rsi
cmpb $0x0, 0x80(%r14)
cmoveq %rcx, %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x525f
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x639b
callq 0x3290
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x63bd
callq 0x3290
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O3/EduBic[P]TSP-MetaheuristicSolvers/TabuSearchSolver.cpp
// Function: TabuSearchSolver::swap(TSPSolution&, move const&)
TSPSolution& TabuSearchSolver::swap(TSPSolution& tspSol, const TSPMove& move) {

    TSPSolution tmpSol(tspSol);

    for ( int i = move.from ; i <= move.to ; ++i ) {
        tspSol.sequence[i] = tmpSol.sequence[move.to-(i-move.from)];
    }

    return tspSol;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61ec
movslq (%r14), %rax
movl 0x4(%r14), %ecx
cmpl %ecx, %eax
jg 0x6b3f
movq 0x8(%rsp), %rdx
movq (%rbx), %rsi
movq %rax, %rdi
decq %rdi
negl %eax
addl (%r14), %ecx
addl %eax, %ecx
movslq %ecx, %rcx
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x4(%rsi,%rdi,4)
movslq 0x4(%r14), %rcx
incq %rdi
decl %eax
cmpq %rcx, %rdi
jl 0x6b22
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b52
callq 0x3290
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6b61
callq 0x3290
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/EduBic[P]TSP-MetaheuristicSolvers/TabuSearchSolver.cpp
// Function: TabuSearchSolver::isTabuMove(int, int)
bool TabuSearchSolver::isTabuMove(int from, int to) {
    /*std::list<TSPMove>::const_iterator it = mTabuList.begin();

    while (it != mTabuList.end()) {
        if ((*it).from == from && (*it).to == to)
            return true;
        it++;
    }*/


    char buffer[50];
    sprintf(buffer, "%u%u", from, to);
    string moveKey = string(buffer);

    if (mTabuSet.find(moveKey) != mTabuSet.end()) {
        return true;
    }

    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rbx
leaq 0x15ff(%rip), %rsi      # 0x8364
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3080
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdi
callq 0x3140
leaq (%rsp,%rax), %rdx
addq $0x20, %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5d1c
leaq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x734c
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6db9
callq 0x3290
addq $0x50, %rbx
cmpq %rbx, %r14
setne %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6de0
callq 0x3290
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/EduBic[P]TSP-MetaheuristicSolvers/./neighborimprovement.h
// Function: BestImprovement::execute(TSP const&, TSPSolution const&, move&)
double execute(const TSP &tsp, const TSPSolution &currSol, TSPMove &move) {
        //cout << endl << endl << "------------- find neighbor --------------";

        // Determine the *move* yielding the best 2-opt neigbor solution
        double bestCostVariation = tsp.infinite;

        // initial and final position are fixed (initial/final node remains 0)
        for ( uint a = 1 ; a < currSol.sequence.size() - 2 ; a++ ) {

            int h = currSol.sequence[a-1];
            int i = currSol.sequence[a];

            for ( uint b = a + 1 ; b < currSol.sequence.size() - 1 ; b++ ) {
                int j = currSol.sequence[b];
                int l = currSol.sequence[b+1];

                // incremental evaluation --> bestCostVariation (instead of best cost)
                double neighCostVariation = - tsp.cost[h][i] - tsp.cost[j][l]
                                            + tsp.cost[h][j] + tsp.cost[i][l];

                //cout << endl << "Move from " << a << " to " << b;
                //cout << "\tNeighbor Variation = " << neighCostVariation << " - BestCostVariation = " << bestCostVariation;

                if ( neighCostVariation < bestCostVariation ) {
                    //cout << "\tSave! Best neighbor found until now";

                    bestCostVariation = neighCostVariation;
                    move.from = a;
                    move.to = b;
                }
            }
        }

        //cout << endl << "-----------------------------" << endl;
        return bestCostVariation;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movsd 0x20(%rsi), %xmm0
movq (%rdx), %rax
movq 0x8(%rdx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
leaq -0x2(%rdx), %rdi
movq %rdi, -0x8(%rsp)
cmpq $0x2, %rdi
jb 0x7ab5
decq %rdx
movq 0x8(%rsi), %rsi
movl $0x1, %r10d
movl $0x1, %r9d
movl $0x3, %r8d
movapd 0x8ab(%rip), %xmm1      # 0x82d0
movl %r10d, %r11d
movq %r9, %rbx
leal 0x1(%r11), %r10d
movl %r10d, %r9d
cmpq %r9, %rdx
jbe 0x7aa7
movslq (%rax,%rbx,4), %r14
leal -0x1(%r11), %ebx
movslq (%rax,%rbx,4), %rbx
leaq (%rbx,%rbx,2), %rbx
movq (%rsi,%rbx,8), %rbx
movsd (%rbx,%r14,8), %xmm2
xorpd %xmm1, %xmm2
leaq (%r14,%r14,2), %r14
movq (%rsi,%r14,8), %r14
movl %r8d, %ebp
movq %r9, %r15
movslq (%rax,%r15,4), %r12
movl %ebp, %r15d
movslq (%rax,%r15,4), %r13
leaq (%r12,%r12,2), %rdi
movq (%rsi,%rdi,8), %rdi
movapd %xmm2, %xmm3
subsd (%rdi,%r13,8), %xmm3
addsd (%rbx,%r12,8), %xmm3
addsd (%r14,%r13,8), %xmm3
ucomisd %xmm3, %xmm0
jbe 0x7a9e
decl %ebp
movl %r11d, (%rcx)
movl %ebp, 0x4(%rcx)
movapd %xmm3, %xmm0
leal 0x1(%r15), %ebp
cmpq %r15, %rdx
ja 0x7a63
incl %r8d
cmpq %r9, -0x8(%rsp)
ja 0x7a25
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/include/policies.hpp
// Function: BackupSmartFilled<boost::intrusive::list<Intrusive<32u, (boost::intrusive::link_mode_type)2>, boost::intrusive::constant_time_size<false>>>::make(unsigned long)
inline static std::unique_ptr<Container> make(std::size_t size){
        if(v.size() != size){
            v.clear();
            v.reserve(size);
            for(std::size_t i = 0; i < size; ++i){
                v.push_back({i});
            }
        }

        std::unique_ptr<Container> container(new Container());

        for(std::size_t i = 0; i < size; ++i){
            container->push_back(v[i]);
        }

        return container;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x2c679(%rip), %rcx     # 0x36240
movq 0x2c66a(%rip), %rax     # 0x36238
movq %rsi, %r14
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
movq %rdi, %rbx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x4, %rdx
imulq %rdx, %rsi
cmpq %r14, %rsi
je 0x9caf
cmpq %rax, %rcx
je 0x9c28
vxorps %xmm0, %xmm0, %xmm0
movq %rax, %rdx
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x9c18
movq 0x8(%rdx), %rdi
movq %rsi, (%rdi)
movq %rdi, 0x8(%rsi)
vmovups %xmm0, (%rdx)
addq $0x30, %rdx
cmpq %rcx, %rdx
jne 0x9c01
movq %rax, 0x2c618(%rip)     # 0x36240
leaq 0x2c609(%rip), %rdi     # 0x36238
movq %r14, %rsi
callq 0x9d2e
testq %r14, %r14
je 0x9caf
leaq 0x10(%rsp), %r13
leaq 0x2c5f0(%rip), %r15     # 0x36238
xorl %ebp, %ebp
movq %rsp, %r12
movq 0x2c5ec(%rip), %rsi     # 0x36240
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movq %rbp, 0x10(%rsp)
cmpq 0x2c5df(%rip), %rsi     # 0x36248
je 0x9c84
vmovups %xmm0, (%rsi)
vmovups (%r13), %ymm0
vmovups %ymm0, 0x10(%rsi)
addq $0x30, 0x2c5be(%rip)    # 0x36240
jmp 0x9c92
movq %r15, %rdi
movq %r12, %rdx
vzeroupper
callq 0x9e54
movq (%rsp), %rax
testq %rax, %rax
je 0x9ca7
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
incq %rbp
cmpq %rbp, %r14
jne 0x9c4d
movl $0x10, %edi
vzeroupper
callq 0x21b0
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %rax, (%rbx)
testq %r14, %r14
je 0x9cff
movq 0x2c566(%rip), %rcx     # 0x36238
xorl %edx, %edx
movq %rax, %rdi
movq %rcx, %rsi
movq %rdi, 0x8(%rsi)
movq %rax, (%rsi)
movq %rsi, 0x8(%rax)
movq %rsi, (%rdi)
leaq (%rdx,%rdx,2), %rdi
incq %rdx
addq $0x30, %rsi
shlq $0x4, %rdi
addq %rcx, %rdi
decq %r14
jne 0x9cda
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x9d26
movq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rcx)
movq %rax, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myInit(int, int)
void myInit(int length, int width){
    dimx = length;
    dimy = width;
    frameBuffer = new int[dimx*dimy];
    depthBuffer = new double[dimx*dimy];
    myLoadIdentity();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x6c7f(%rip), %rax      # 0xa228
movl %edi, (%rax)
leaq 0x6c7a(%rip), %rax      # 0xa22c
movl %esi, (%rax)
imull %edi, %esi
movslq %esi, %rax
leaq (,%rax,4), %rdi
testl %eax, %eax
movq $-0x1, %rcx
cmovsq %rcx, %rdi
leaq (,%rax,8), %rbx
cmovsq %rcx, %rbx
callq 0x1030
leaq 0x6c31(%rip), %rcx      # 0xa218
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x1030
leaq 0x6c27(%rip), %rcx      # 0xa220
movq %rax, (%rcx)
leaq 0x6b5d(%rip), %rax      # 0xa160
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq %rcx, 0x28(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq %rcx, 0x50(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
movq %rcx, 0x78(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myLoadIdentity()
void myLoadIdentity(){
    modelMatrix[0][0] = 1; modelMatrix[0][1] = 0; modelMatrix[0][2] = 0; modelMatrix[0][3] = 0;
    modelMatrix[1][0] = 0; modelMatrix[1][1] = 1; modelMatrix[1][2] = 0; modelMatrix[1][3] = 0;
    modelMatrix[2][0] = 0; modelMatrix[2][1] = 0; modelMatrix[2][2] = 1; modelMatrix[2][3] = 0;
    modelMatrix[3][0] = 0; modelMatrix[3][1] = 0; modelMatrix[3][2] = 0; modelMatrix[3][3] = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6b17(%rip), %rax      # 0xa160
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq %rcx, 0x28(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq %rcx, 0x50(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
movq %rcx, 0x78(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myFrustum(double, double, double, double, double, double)
void myFrustum(double left, double right, double bottom, double top, double zNear, double zFar){
    frustumLeft = left;
    frustumRight = right;
    frustumBottom = bottom;
    frustumTop = top;
    frustumNear = zNear;
    frustumFar = zFar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6b56(%rip), %rax      # 0xa1e0
movsd %xmm0, (%rax)
leaq 0x6b53(%rip), %rax      # 0xa1e8
movsd %xmm1, (%rax)
leaq 0x6b50(%rip), %rax      # 0xa1f0
movsd %xmm2, (%rax)
leaq 0x6b4d(%rip), %rax      # 0xa1f8
movsd %xmm3, (%rax)
leaq 0x6b4a(%rip), %rax      # 0xa200
movsd %xmm4, (%rax)
leaq 0x6b47(%rip), %rax      # 0xa208
movsd %xmm5, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myScaled(double, double, double)
void myScaled(double x, double y, double z){
    double matrix[4][4], omatrix[4][4];
    matrix[0][0] = x; matrix[0][1] = 0; matrix[0][2] = 0; matrix[0][3] = 0;
    matrix[1][0] = 0; matrix[1][1] = y; matrix[1][2] = 0; matrix[1][3] = 0;
    matrix[2][0] = 0; matrix[2][1] = 0; matrix[2][2] = z; matrix[2][3] = 0;
    matrix[3][0] = 0; matrix[3][1] = 0; matrix[3][2] = 0; matrix[3][3] = 1;
    multiMatrix(modelMatrix, matrix, omatrix);
    for(int i = 0; i < 4; i ++){
        for(int j = 0; j < 4; j ++)
            modelMatrix[i][j] = omatrix[i][j];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq -0x110(%rbp), %rsi
movsd %xmm0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movups %xmm0, 0x18(%rsi)
movsd %xmm1, 0x28(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movsd %xmm2, 0x50(%rsi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x68(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsi)
leaq 0x6754(%rip), %rbx      # 0xa160
leaq -0x90(%rbp), %rdx
movq %rbx, %rdi
callq 0x4bd0
xorl %eax, %eax
movaps -0x90(%rbp,%rax), %xmm0
movaps -0x80(%rbp,%rax), %xmm1
movaps %xmm1, 0x10(%rbx,%rax)
movaps %xmm0, (%rbx,%rax)
addq $0x20, %rax
cmpq $0x80, %rax
jne 0x3a1d
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myPushMatrix()
void myPushMatrix(){
    double** matrix = new double*[4];
    matrix[0] = new double[4];
    matrix[1] = new double[4];
    matrix[2] = new double[4];
    matrix[3] = new double[4];
    for(int i = 0; i < 4; i ++){
        for(int j = 0; j < 4; j ++)
            matrix[i][j] = modelMatrix[i][j];
    }
    modelMatrixStack.push(matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x20, %edi
callq 0x1030
movq %rax, %rbx
movq %rax, -0x10(%rbp)
movl $0x20, %edi
callq 0x1030
movq %rax, (%rbx)
movl $0x20, %edi
callq 0x1030
movq %rax, 0x8(%rbx)
movl $0x20, %edi
callq 0x1030
movq %rax, 0x10(%rbx)
movl $0x20, %edi
callq 0x1030
movq %rax, 0x18(%rbx)
leaq 0x60b8(%rip), %rax      # 0xa160
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq $0x4, %rsi
jne 0x40b0
incq %rcx
addq $0x20, %rax
cmpq $0x4, %rcx
jne 0x40aa
leaq 0x6031(%rip), %rax      # 0xa108
movq 0x30(%rax), %rcx
movq 0x40(%rax), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x40f2
movq %rbx, (%rcx)
addq $0x8, 0x30(%rax)
jmp 0x4102
leaq 0x600f(%rip), %rdi      # 0xa108
leaq -0x10(%rbp), %rsi
callq 0x4838
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: mySwapBuffers()
void mySwapBuffers(){
    char s[10];
    sprintf(s, "%03d.ppm", frame);
    FILE *fp = fopen(s, "wb");
    (void) fprintf(fp, "P1\n%d %d\n", dimx, dimy);
    for(int i = 0; i < dimx*dimy; i++){
        (void) fprintf(fp, "%d", frameBuffer[i]);
    }
    frame++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x60a3(%rip), %rax      # 0xa230
movl (%rax), %edx
leaq 0x31ca(%rip), %rsi      # 0x7360
leaq -0x32(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
leaq 0x31be(%rip), %rsi      # 0x7369
movq %rbx, %rdi
callq 0x1110
movq %rax, %rbx
leaq 0x606b(%rip), %r14      # 0xa228
movl (%r14), %edx
leaq 0x6065(%rip), %r15      # 0xa22c
movl (%r15), %ecx
leaq 0x319b(%rip), %rsi      # 0x736c
movq %rax, %rdi
xorl %eax, %eax
callq 0x1120
movl (%r15), %eax
imull (%r14), %eax
testl %eax, %eax
jle 0x4227
movq %r14, %rdx
leaq 0x3186(%rip), %r14      # 0x7376
xorl %r12d, %r12d
leaq 0x601e(%rip), %rax      # 0xa218
movq (%rax), %rax
movq %rdx, %r13
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1120
movq %r13, %rdx
incq %r12
movslq (%r13), %rax
movslq (%r15), %rcx
imulq %rax, %rcx
cmpq %rcx, %r12
jl 0x41f3
leaq 0x6002(%rip), %rax      # 0xa230
incl (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: modelTransform(vertex)
vertex modelTransform(vertex v){
    double ox = modelMatrix[0][0] * v.x + modelMatrix[0][1] * v.y + modelMatrix[0][2] * v.z + modelMatrix[0][3];
    double oy = modelMatrix[1][0] * v.x + modelMatrix[1][1] * v.y + modelMatrix[1][2] * v.z + modelMatrix[1][3];
    double oz = modelMatrix[2][0] * v.x + modelMatrix[2][1] * v.y + modelMatrix[2][2] * v.z + modelMatrix[2][3];
    double oc = modelMatrix[3][0] * v.x + modelMatrix[3][1] * v.y + modelMatrix[3][2] * v.z + modelMatrix[3][3];
    return vertex(ox/oc, oy/oc, oz/oc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd 0x10(%rbp), %xmm0
movsd 0x18(%rbp), %xmm3
movsd 0x5692(%rip), %xmm1     # 0xa168
mulsd %xmm3, %xmm1
movsd 0x567e(%rip), %xmm4     # 0xa160
mulsd %xmm0, %xmm4
addsd %xmm1, %xmm4
movsd 0x20(%rbp), %xmm2
movsd 0x5679(%rip), %xmm1     # 0xa170
mulsd %xmm2, %xmm1
addsd %xmm4, %xmm1
addsd 0x5671(%rip), %xmm1     # 0xa178
movsd 0x5679(%rip), %xmm4     # 0xa188
mulsd %xmm3, %xmm4
movsd 0x5665(%rip), %xmm5     # 0xa180
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
movsd 0x5665(%rip), %xmm4     # 0xa190
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
addsd 0x565d(%rip), %xmm4     # 0xa198
movsd 0x5665(%rip), %xmm5     # 0xa1a8
mulsd %xmm3, %xmm5
movsd 0x5651(%rip), %xmm6     # 0xa1a0
mulsd %xmm0, %xmm6
addsd %xmm5, %xmm6
movsd 0x5651(%rip), %xmm5     # 0xa1b0
mulsd %xmm2, %xmm5
addsd %xmm6, %xmm5
addsd 0x5649(%rip), %xmm5     # 0xa1b8
mulsd 0x5651(%rip), %xmm3     # 0xa1c8
mulsd 0x5641(%rip), %xmm0     # 0xa1c0
mulsd 0x5649(%rip), %xmm2     # 0xa1d0
addsd %xmm3, %xmm0
addsd %xmm0, %xmm2
addsd 0x5641(%rip), %xmm2     # 0xa1d8
movq %rdi, %rax
divsd %xmm2, %xmm1
divsd %xmm2, %xmm4
divsd %xmm2, %xmm5
movsd %xmm1, (%rdi)
movsd %xmm4, 0x8(%rdi)
movsd %xmm5, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: multiMatrix(double (*) [4], double (*) [4], double (*) [4])
void multiMatrix(double imat1[4][4], double imat2[4][4], double omat[4][4]){
    for(int i = 0; i < 4; i++){
        for(int j = 0; j < 4; j++){
            omat[i][j] = 0;
            for(int k = 0; k < 4; k++)
                omat[i][j] += imat1[i][k] * imat2[k][j];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rax, %rcx
shlq $0x5, %rcx
addq %rdx, %rcx
movq %rsi, %r8
xorl %r9d, %r9d
leaq (%rcx,%r9,8), %r10
movq $0x0, (%r10)
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
movsd (%rdi,%r11), %xmm1
mulsd (%r8,%r11,4), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r10)
addq $0x8, %r11
cmpq $0x20, %r11
jne 0x4bf8
incq %r9
addq $0x8, %r8
cmpq $0x4, %r9
jne 0x4be6
incq %rax
addq $0x20, %rdi
cmpq $0x4, %rax
jne 0x4bd6
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: inputBuffer(int, int, double)
void inputBuffer(int x, int y, double zDepth){
    int pixel = (y - 1) * dimx + x;
    if(x > 0 && x <= dimx && y > 0 && y <= dimy && zDepth >= depthBuffer[pixel - 1]){
        frameBuffer[(pixel - 1)] = 0;
        depthBuffer[pixel - 1] = zDepth;
    }
}

// Assembly:
testl %edi, %edi
jle 0x4c7e
testl %esi, %esi
jle 0x4c7e
movl 0x55e7(%rip), %eax      # 0xa228
cmpl %edi, %eax
jl 0x4c7e
cmpl %esi, 0x55e1(%rip)      # 0xa22c
jl 0x4c7e
pushq %rbp
movq %rsp, %rbp
decl %esi
imull %esi, %eax
movq 0x55c3(%rip), %rcx      # 0xa220
addl %edi, %eax
decl %eax
cltq
ucomisd (%rcx,%rax,8), %xmm0
jb 0x4c7d
movq 0x55a7(%rip), %rdx      # 0xa218
movl $0x0, (%rdx,%rax,4)
movsd %xmm0, (%rcx,%rax,8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: hidenSurface(int, int, double)
void hidenSurface(int x, int y, double zDepth){
    int pixel = (y - 1) * dimx + x;
    if(x > 0 && x <= dimx && y > 0 && y <= dimy && zDepth >= depthBuffer[pixel - 1]){
        frameBuffer[(pixel - 1)] = 1;
        depthBuffer[pixel - 1] = zDepth;
    }
}

// Assembly:
testl %edi, %edi
jle 0x4cca
testl %esi, %esi
jle 0x4cca
movl 0x559b(%rip), %eax      # 0xa228
cmpl %edi, %eax
jl 0x4cca
cmpl %esi, 0x5595(%rip)      # 0xa22c
jl 0x4cca
pushq %rbp
movq %rsp, %rbp
decl %esi
imull %esi, %eax
movq 0x5577(%rip), %rcx      # 0xa220
addl %edi, %eax
decl %eax
cltq
ucomisd (%rcx,%rax,8), %xmm0
jb 0x4cc9
movq 0x555b(%rip), %rdx      # 0xa218
movl $0x1, (%rdx,%rax,4)
movsd %xmm0, (%rcx,%rax,8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/thunlp[P]KB2E/TransE/Test_TransE.cpp
// Function: Test::calc_sum(int, int, int)
double calc_sum(int e1,int e2,int rel)
    {
        double sum=0;
        if (L1_flag)
        	for (int ii=0; ii<n; ii++)
            sum+=-fabs(entity_vec[e2][ii]-entity_vec[e1][ii]-relation_vec[rel][ii]);
        else
        for (int ii=0; ii<n; ii++)
            sum+=-sqr(entity_vec[e2][ii]-entity_vec[e1][ii]-relation_vec[rel][ii]);
        return sum;
    }

// Assembly:
movl 0x6d6c(%rip), %eax      # 0xc15c
cmpb $0x0, 0x6d61(%rip)      # 0xc158
je 0x5458
testl %eax, %eax
jle 0x54aa
movslq %edx, %rdx
movq (%rdi), %r8
movq 0x18(%rdi), %rdi
leaq (%rdx,%rdx,2), %rdx
movq (%rdi,%rdx,8), %rdx
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
movq (%rdi,%rsi,8), %rsi
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%r8,%rcx,8), %rcx
xorpd %xmm0, %xmm0
xorl %edi, %edi
movapd 0x2c19(%rip), %xmm1     # 0x8050
movsd (%rdx,%rdi,8), %xmm2
subsd (%rsi,%rdi,8), %xmm2
subsd (%rcx,%rdi,8), %xmm2
andpd %xmm1, %xmm2
subsd %xmm2, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x5437
jmp 0x54a9
testl %eax, %eax
jle 0x54aa
movslq %edx, %rdx
movq (%rdi), %r8
movq 0x18(%rdi), %rdi
leaq (%rdx,%rdx,2), %rdx
movq (%rdi,%rdx,8), %rdx
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
movq (%rdi,%rsi,8), %rsi
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%r8,%rcx,8), %rcx
xorpd %xmm0, %xmm0
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm1
subsd (%rsi,%rdi,8), %xmm1
subsd (%rcx,%rdi,8), %xmm1
mulsd %xmm1, %xmm1
subsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x548a
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/shreyas-gopalakrishna[P]Concurrent-Skip-list/unit_test_3.cpp
// Function: skiplist_combined_operations()
void skiplist_combined_operations(){

    int start = (rand() % static_cast<int>(numbers_insert.size() + 1));
    int end = start + (rand() % static_cast<int>(numbers_insert.size() - start + 1));
    // cout << "Add Index: " << start << " " << end << endl;
    skiplist_add(start, end);

    start = (rand() % static_cast<int>(numbers_delete.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_delete.size() - start + 1));
    // cout << "Remove Index: " << start << " " << end << endl;
    skiplist_remove(start, end);

    start = (rand() % static_cast<int>(numbers_get.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_get.size() - start + 1));
    // cout << "Searching Index: " << start << " " << end << endl;
    skiplist_search(start, end);

    start = (rand() % static_cast<int>(numbers_insert.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_insert.size() - start + 1));
    // cout << "Range: " << start << " " << end << endl;
    skiplist_range(start, end);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
callq 0x2060
movq 0x6728(%rip), %rcx      # 0x91b0
subq 0x6719(%rip), %rcx      # 0x91a8
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x670a(%rip), %rcx      # 0x91b0
subq 0x66fb(%rip), %rcx      # 0x91a8
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x2715
callq 0x2060
movq 0x66f7(%rip), %rcx      # 0x91c8
subq 0x66e8(%rip), %rcx      # 0x91c0
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x66d9(%rip), %rcx      # 0x91c8
subq 0x66ca(%rip), %rcx      # 0x91c0
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x295d
callq 0x2060
movq 0x66c6(%rip), %rcx      # 0x91e0
subq 0x66b7(%rip), %rcx      # 0x91d8
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x66a8(%rip), %rcx      # 0x91e0
subq 0x6699(%rip), %rcx      # 0x91d8
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x29c1
callq 0x2060
movq 0x664d(%rip), %rcx      # 0x91b0
subq 0x663e(%rip), %rcx      # 0x91a8
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x662f(%rip), %rcx      # 0x91b0
subq 0x6620(%rip), %rcx      # 0x91a8
shrq $0x2, %rcx
subl %ebx, %ecx
incl %ecx
cltd
idivl %ecx
leal (%rdx,%rbx), %ecx
leaq 0x65fb(%rip), %rsi      # 0x9198
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebx, %edx
callq 0x50f0
movq %r14, %rdi
callq 0x39a6
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/kaityo256[P]cps/cps.cpp
// Function: worker(int)
void worker(const int rank) {
  while (true) {
    int send = 10;
    int len = 0;
    MPI_Status st;
    // Sends dummy data to notify that communication is ready.
    MPI_Send(&send, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
    // Recieve the length of a command
    MPI_Recv(&len, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &st);
    // If the length is zero, all tasks are completed.
    if (len == 0) {
      debug_printf("Finish OK: %d\n", rank);
      break;
    }
    std::unique_ptr<char[]> buf(new char[len]);
    MPI_Recv(buf.get(), len, MPI_CHAR, 0, 0, MPI_COMM_WORLD, &st);
    std::string recv_string = buf.get();
    debug_printf("%d: Recieved %s\n", rank, recv_string.c_str());
    std::system(recv_string.c_str());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x332c(%rip), %rbx      # 0x5fc8
movq 0x32fd(%rip), %r14      # 0x5fa0
leaq -0x70(%rbp), %r13
movl $0xa, -0x34(%rbp)
movl $0x0, -0x30(%rbp)
leaq -0x34(%rbp), %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2090
movq %r13, (%rsp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2130
movl -0x30(%rbp), %r12d
testl %r12d, %r12d
je 0x2d5e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %r12d, %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r15
movq %r13, (%rsp)
movq %rax, %rdi
movl %r12d, %esi
movq 0x3277(%rip), %rdx      # 0x5f90
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2130
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
leaq -0x29(%rbp), %rdx
callq 0x20b0
movq -0x58(%rbp), %rdi
callq 0x2160
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2d51
callq 0x2180
movq %r15, %rdi
callq 0x21f0
jmp 0x2ca7
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d6f
movq %rax, %rbx
jmp 0x2d89
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2d89
callq 0x2180
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/kaityo256[P]cps/cps.cpp
// Function: main
int main(int argc, char **argv) {
  MPI_Init(&argc, &argv);
  int rank, procs;
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  MPI_Comm_size(MPI_COMM_WORLD, &procs);

  if (argc < 2 || procs < 2) {
    if (rank == 0) {
      fprintf(stderr, "Usage: mpirun -np num_procs ./cps tasklist\n");
      fprintf(stderr, "num_procs must be 2 or more.\n");
    }
    MPI_Finalize();
    return 1;
  }

  int is_ready = loadfile(argc, argv);
  int all_ready = 0;
  MPI_Allreduce(&is_ready, &all_ready, 1, MPI_INT, MPI_LAND, MPI_COMM_WORLD);

  if (all_ready) {
    if (rank == 0) {
      manager(procs);
    } else {
      worker(rank);
    }
  }

  MPI_Finalize();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x2c(%rbp), %rbx
movl %edi, (%rbx)
leaq -0x20(%rbp), %rax
movq %rsi, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2210
movq 0x2fa1(%rip), %r14      # 0x5fa0
leaq -0x18(%rbp), %rsi
movq %r14, %rdi
callq 0x2200
leaq -0x14(%rbp), %rsi
movq %r14, %rdi
callq 0x21d0
movl (%rbx), %edi
cmpl $0x2, %edi
jl 0x3071
cmpl $0x1, -0x14(%rbp)
jle 0x3071
movq -0x20(%rbp), %rsi
callq 0x2d99
leaq -0x28(%rbp), %rdi
movl %eax, (%rdi)
leaq -0x24(%rbp), %rbx
movl $0x0, (%rbx)
movq 0x2f84(%rip), %rcx      # 0x5fc8
movq 0x2f5d(%rip), %r8       # 0x5fa8
movq 0x2f4e(%rip), %r9       # 0x5fa0
movq %rbx, %rsi
movl $0x1, %edx
callq 0x21e0
cmpl $0x0, (%rbx)
je 0x308b
cmpl $0x0, -0x18(%rbp)
je 0x3083
callq 0x2c84
jmp 0x308b
cmpl $0x0, -0x18(%rbp)
je 0x309b
callq 0x2110
movl $0x1, %eax
jmp 0x3092
movl -0x14(%rbp), %edi
callq 0x258c
callq 0x2110
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x22f0
jmp 0x3077
// File: /workspace/github_cpp_makefile_star2_O3/king1600[P]cordpp/src/base64.cc
// Function: cordpp::b64_encode(char const*, unsigned long)
char* cordpp::b64_encode(const char *src, const size_t length) {
  // (length * 4 / 3) rounded up to nearest multiple of 4
  const size_t encoded_length = ((length<<2)/3+3)&-4;
  char *buffer = new char[encoded_length + 1];

  // perform base64 calculation
  size_t i;
  char *p = buffer;
  for(i = 0; i < length-2; i += 3) {
      *p++ = B64_CHARSET[(src[i] >> 2) & 0x3F];
      *p++ = B64_CHARSET[((uint8_t)src[i] << 4 | (uint8_t)src[i+1] >> 4) & 0x3F];
      *p++ = B64_CHARSET[((uint8_t)src[i+1] << 2 | (uint8_t)src[i+2] >> 6) & 0x3F];
      *p++ = B64_CHARSET[(uint8_t)src[i+2] & 0x3F];
  }

  // this returns 3 instead of 0 if we need no padding but
  // if we need no padding we dont need to do anything
  int padding = (length % 3)^3;
  if (padding == 1) {
      *p++ = B64_CHARSET[(src[i] >> 2) & 0x3F];
      *p++ = B64_CHARSET[(src[i] << 4 | src[i+1] >> 4) & 0x3F];
      *p++ = B64_CHARSET[(src[i+1] << 2) & 0x3F];
      *p++ = '=';
  } else if (padding == 2) {
      *p++ = B64_CHARSET[(src[i] >> 2) & 0x3F];
      *p++ = B64_CHARSET[(src[i] << 4) & 0x3F];
      *p++ = '=';
      *p++ = '=';
  }

  // add null terminator and return constructed buffer
  *p = '\0';
  return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq (,%rsi,4), %rax
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
mulq %r15
shrq %rdx
leaq 0x3(%rdx), %rdi
andq $-0x4, %rdi
incq %rdi
callq 0xa040
movq %rax, %rcx
movq %r14, %rax
xorl %edi, %edi
addq $-0x2, %rax
je 0xc83b
leaq 0x2e858(%rip), %r8      # 0x3b010
movq %rcx, %rsi
movzbl (%rbx,%rdi), %edx
movl %edx, %r9d
shrl $0x2, %r9d
movb (%r9,%r8), %r9b
movb %r9b, (%rsi)
shll $0x4, %edx
movzbl 0x1(%rbx,%rdi), %r9d
movl %r9d, %r10d
shrl $0x4, %r10d
andl $0x30, %edx
orl %r10d, %edx
movb (%rdx,%r8), %dl
movb %dl, 0x1(%rsi)
movzbl 0x2(%rbx,%rdi), %edx
movl %edx, %r10d
shrl $0x6, %r10d
andl $0xf, %r9d
leal (%r10,%r9,4), %r9d
movb (%r9,%r8), %r9b
movb %r9b, 0x2(%rsi)
andl $0x3f, %edx
movb (%rdx,%r8), %dl
movb %dl, 0x3(%rsi)
addq $0x4, %rsi
addq $0x3, %rdi
cmpq %rax, %rdi
jb 0xc7bb
movq %r14, %rax
mulq %r15
shrq %rdx
leaq (%rdx,%rdx,2), %rax
subq %rax, %r14
cmpq $0x1, %r14
je 0xc882
cmpq $0x2, %r14
je 0xc83e
jmp 0xc8ad
movq %rcx, %rsi
movzbl (%rbx,%rdi), %eax
movl %eax, %edx
shrl $0x2, %edx
leaq 0x2e7c2(%rip), %r8      # 0x3b010
movb (%rdx,%r8), %dl
movb %dl, (%rsi)
shll $0x4, %eax
movzbl 0x1(%rbx,%rdi), %edx
movl %edx, %edi
sarb $0x4, %dil
movzbl %dil, %edi
orl %eax, %edi
andl $0x3f, %edi
movb (%rdi,%r8), %al
movb %al, 0x1(%rsi)
andl $0xf, %edx
movb (%r8,%rdx,4), %dl
leaq 0x3(%rsi), %rax
movb %dl, 0x2(%rsi)
jmp 0xc8a6
movzbl (%rbx,%rdi), %eax
movl %eax, %edx
shrl $0x2, %edx
movb (%rdx,%r8), %dl
movb %dl, (%rsi)
shll $0x4, %eax
andl $0x30, %eax
movb (%rax,%r8), %al
movb %al, 0x1(%rsi)
leaq 0x3(%rsi), %rax
movb $0x3d, 0x2(%rsi)
addq $0x4, %rsi
movb $0x3d, (%rax)
movb $0x0, (%rsi)
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/king1600[P]cordpp/src/base64.cc
// Function: cordpp::b64_decode(char const*)
char* cordpp::b64_decode(const char *src) {
  // The input is invalid or not properly padded
  const size_t src_len = std::strlen(src);
  if (src_len % 4 != 0)
    return nullptr;

  // instead of figuring out exactly how long the decoded string should be
  // allocate enough. at most this is an extra 2 bytes
  char *buffer = new char[(src_len * 3 >> 2) + 1];

  // decode content with lookup table
  size_t i;
  char *p = buffer;
  for(i = 0; i < src_len - 4; i += 4) {
    *p++ = (B64_LOOKUP[(uint8_t)src[i]] << 2 | B64_LOOKUP[(uint8_t)src[i+1]] >> 4) & 0xff;
    *p++ = (B64_LOOKUP[(uint8_t)src[i+1]] << 4 | B64_LOOKUP[(uint8_t)src[i+2]] >> 2) & 0xff;
    *p++ = (B64_LOOKUP[(uint8_t)src[i+2]] << 6 | B64_LOOKUP[(uint8_t)src[i+3]]) & 0xff;
  }

  // decode padding
  *p++ = (B64_LOOKUP[(uint8_t)src[i]] << 2 | B64_LOOKUP[(uint8_t)src[i+1]] >> 4) & 0xff;

  // decode rest of padding
  if (src[i+2] != '=') {
    *p++ = (B64_LOOKUP[(uint8_t)src[i+1]] << 4 | B64_LOOKUP[(uint8_t)src[i+2]] >> 2) & 0xff;
    if (src[i+3] != '=')
      *p++ = (B64_LOOKUP[(uint8_t)src[i+2]] << 6 | B64_LOOKUP[(uint8_t)src[i+3]]) & 0xff;
    else
      *p++ = B64_LOOKUP[(uint8_t)src[i+2]] << 6 & 0xff;
  } else {
    *p++ = B64_LOOKUP[(uint8_t)src[i+1]] << 4 & 0xff;
  }

  // add null terminator and return constructed buffer
  *p = '\0';
  return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xa2a0
movq %rax, %r14
testb $0x3, %r14b
je 0xc8d5
xorl %eax, %eax
jmp 0xc9cc
leaq (%r14,%r14,2), %rdi
shrq $0x2, %rdi
incq %rdi
callq 0xa040
xorl %edx, %edx
addq $-0x4, %r14
je 0xc956
leaq 0x2e76c(%rip), %rsi     # 0x3b060
movq %rax, %rcx
movzbl (%rbx,%rdx), %edi
movb (%rdi,%rsi), %dil
shlb $0x2, %dil
movzbl 0x1(%rbx,%rdx), %r8d
movb (%r8,%rsi), %r8b
movl %r8d, %r9d
shrb $0x4, %r9b
orb %dil, %r9b
movb %r9b, (%rcx)
shlb $0x4, %r8b
movzbl 0x2(%rbx,%rdx), %edi
movb (%rdi,%rsi), %dil
movl %edi, %r9d
shrb $0x2, %r9b
orb %r8b, %r9b
movb %r9b, 0x1(%rcx)
shlb $0x6, %dil
movzbl 0x3(%rbx,%rdx), %r8d
orb (%r8,%rsi), %dil
movb %dil, 0x2(%rcx)
addq $0x3, %rcx
addq $0x4, %rdx
cmpq %r14, %rdx
jb 0xc8f7
jmp 0xc959
movq %rax, %rcx
movzbl (%rbx,%rdx), %edi
leaq 0x2e6fc(%rip), %rsi     # 0x3b060
movb (%rdi,%rsi), %r8b
shlb $0x2, %r8b
movzbl 0x1(%rbx,%rdx), %edi
movb (%rdi,%rsi), %dil
movl %edi, %r9d
shrb $0x4, %r9b
orb %r8b, %r9b
movb %r9b, (%rcx)
movzbl 0x2(%rbx,%rdx), %r8d
shlb $0x4, %dil
cmpq $0x3d, %r8
jne 0xc99c
movb %dil, 0x1(%rcx)
addq $0x2, %rcx
jmp 0xc9c9
movb (%r8,%rsi), %r8b
movl %r8d, %r9d
shrb $0x2, %r9b
orb %dil, %r9b
movb %r9b, 0x1(%rcx)
movzbl 0x3(%rbx,%rdx), %edx
shlb $0x6, %r8b
cmpq $0x3d, %rdx
je 0xc9c1
orb (%rdx,%rsi), %r8b
movb %r8b, 0x2(%rcx)
addq $0x3, %rcx
movb $0x0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/king1600[P]cordpp/./include/collection.h
// Function: cordpp::Collection<cordpp::Overwrite>::Collection()
Collection() {
      pos = 0;
      marking = 0;
      csize = 10;
      frag_rate = 3;
      frag_count = 0;
      list = new CollectionItem[csize];
      for (slot = 0; slot < csize; slot++)
        list[slot] = {nullptr, slot, 0};
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, (%rdi)
movq %r14, 0x18(%rdi)
movq $0xa, 0x10(%rdi)
movq $0x3, 0x20(%rdi)
movq %r14, 0x28(%rdi)
movl $0xf0, %edi
callq 0xa040
movq %rax, 0x30(%rbx)
movq %r14, 0x8(%rbx)
xorl %eax, %eax
movq 0x30(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
movq %r14, (%rcx,%rdx,8)
movq %rax, 0x8(%rcx,%rdx,8)
movq %r14, 0x10(%rcx,%rdx,8)
movq 0x8(%rbx), %rax
incq %rax
movq %rax, 0x8(%rbx)
cmpq 0x10(%rbx), %rax
jb 0xcc5f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/king1600[P]cordpp/./include/collection.h
// Function: cordpp::Collection<cordpp::Overwrite>::cache_size(unsigned long)
const size_t cache_size(const size_t new_size = 0) {
      if (new_size < 1)
        return csize;
      CollectionItem *new_list = new CollectionItem[new_size];
      for (slot = 0; slot < new_size; slot++)
        new_list[slot] = slot <= csize ? 
          list[csize - slot] : CollectionItem{nullptr, slot, 0};
      csize = new_size;
      delete list;
      list = new_list;
      return csize;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xcd3e
movq %rsi, %r14
movl $0x18, %ecx
movq %rsi, %rax
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0xa040
movq %rax, %r15
leaq 0x10(%rbx), %r12
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rdi
movq $0x0, 0x8(%rbx)
leaq (%rax,%rax,2), %rcx
leaq (%rdi,%rcx,8), %rcx
addq $0x10, %rcx
movq %r15, %rdx
addq $0x10, %rdx
xorl %esi, %esi
movl $0x0, %r8d
movq %rsi, %r9
movl $0x0, %r10d
cmpq %rax, %rsi
ja 0xcd0b
movq -0x10(%rcx), %r10
movq -0x8(%rcx), %r9
movq (%rcx), %r8
movq %r10, -0x10(%rdx)
movq %r9, -0x8(%rdx)
movq %r8, (%rdx)
incq %rsi
movq %rsi, 0x8(%rbx)
addq $-0x18, %rcx
addq $0x18, %rdx
cmpq %rsi, %r14
jne 0xccec
movq %r14, 0x10(%rbx)
movl $0x18, %esi
callq 0xa5d0
movq %r15, 0x30(%rbx)
jmp 0xcd45
addq $0x10, %rbx
movq %rbx, %r12
movq (%r12), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/king1600[P]cordpp/./include/collection.h
// Function: cordpp::Collection<cordpp::Emoji>::clear()
void clear() {
      pos = 0;
      for (slot = 0; slot < csize; slot++) {
        if (list[slot].item != nullptr) {
          delete list[slot].item;
          list[slot].marker = 0;
        }
      }
    }

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x20f97
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdx
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rsi
movq (%rdx,%rsi,8), %r14
testq %r14, %r14
je 0x20f84
leaq 0x38(%r14), %rdi
callq 0x20e86
movq 0x68(%r14), %rdi
movl $0x18, %esi
callq 0xa5d0
movq 0x10(%r14), %rdi
leaq 0x20(%r14), %rax
cmpq %rax, %rdi
je 0x20f5e
movq (%rax), %rsi
incq %rsi
callq 0xa5d0
movl $0x78, %esi
movq %r14, %rdi
callq 0xa5d0
movq 0x8(%rbx), %rcx
movq 0x30(%rbx), %rdx
leaq (%rcx,%rcx,2), %rax
movq $0x0, 0x10(%rdx,%rax,8)
movq 0x10(%rbx), %rax
incq %rcx
movq %rcx, 0x8(%rbx)
cmpq %rax, %rcx
jb 0x20f22
addq $0x8, %rsp
popq %rbx
popq %r14
retq