LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x3c(%rsp), %edi
callq 0x3270
movl $0x1, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movl 0x38(%rsp), %eax
movq %rax, 0x18(%rsp)
callq 0x7c40
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x5758
callq 0x30c0
movq 0x20(%rsp), %rdi
cltq
movq %rax, (%rsp)
callq 0x7c40
movq %rax, %rcx
movq (%rsp), %rax
subq $0x2, %rcx
xorl %edx, %edx
divq %rcx
addq $0x1, %rdx
movl %edx, %eax
movl %eax, 0x34(%rsp)
callq 0x30c0
movq 0x20(%rsp), %rdi
cltq
movq %rax, 0x8(%rsp)
callq 0x7c40
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x2, %rcx
xorl %edx, %edx
divq %rcx
addq $0x1, %rdx
movl %edx, %eax
movl %eax, 0x30(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x8700
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movslq 0x30(%rsp), %rsi
callq 0x8700
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x10(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x8700
movl 0x10(%rsp), %ecx
movq 0x20(%rsp), %rdi
movl %ecx, (%rax)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movslq 0x30(%rsp), %rsi
callq 0x8700
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x5668
movq 0xe871(%rip), %rdi      # 0x13fd0
leaq 0x8af7(%rip), %rsi      # 0xe25d
callq 0x3280
movq %rax, %rdi
movq 0xe83b(%rip), %rsi      # 0x13fb0
callq 0x32b0
movq 0x20(%rsp), %rdi
movq 0xe84a(%rip), %rsi      # 0x13fd0
callq 0x8720
movq 0xe83e(%rip), %rdi      # 0x13fd0
leaq 0x8ac4(%rip), %rsi      # 0xe25d
callq 0x3280
movq %rax, %rdi
movq 0xe808(%rip), %rsi      # 0x13fb0
callq 0x32b0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, (%rsp)
callq 0x7c40
movq %rax, %rcx
movq (%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x5cac
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x87d0
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x87d0
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
movslq 0x18(%rsp), %rsi
callq 0x87f0
movq %rax, %rdi
movslq 0x14(%rsp), %rsi
callq 0x8810
movsd (%rax), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5c19
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0xb86c(%rip), %rsi      # 0x13fb0
callq 0x32b0
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movq %rax, 0x10(%rsp)
callq 0x7c40
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x87b3
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x87d0
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x3410
movq %rax, %rdi
leaq 0x599c(%rip), %rsi      # 0xe13d
callq 0x3280
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x8751
movq 0x28(%rsp), %rdi
movq 0xb7f1(%rip), %rsi      # 0x13fb0
callq 0x32b0
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x9e80
movq 0x60(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x60(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x9e55
leaq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x4(%rax), %eax
movl 0xc(%rsp), %ecx
movq 0x60(%rsp), %rdx
subl (%rdx), %ecx
subl %ecx, %eax
movslq %eax, %rsi
callq 0x8700
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x8700
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x9dfd
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0xa060
movq (%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x7950
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x18(%rsp)
callq 0x3330
movq 0x38(%rsp), %rdi
callq 0x7c40
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x7960
jmp 0x9ed1
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x7c40
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x9f4b
movq 0x38(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x87d0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x7a70
jmp 0x9f18
jmp 0x9f1a
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x9ed9
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x31b0
movq 0x20(%rsp), %rdi
callq 0x7b10
jmp 0x9f97
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x3040
jmp 0x9f64
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
movsd 0x38(%rcx), %xmm0
movsd %xmm0, 0x38(%rax)
movq 0x38(%rsp), %rcx
movsd 0x40(%rcx), %xmm0
movsd %xmm0, 0x40(%rax)
movq 0x38(%rsp), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, 0x48(%rax)
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: EduBic[P]TSP-MetaheuristicSolvers/./TSPSolution.h
// Function: TSPSolution::operator=(TSPSolution const&)
TSPSolution& operator=(const TSPSolution& right) {

        // Handle self-assignment:
        if(this == &right) {
            return *this;
        }
        else { // if (this != &right)
            for (uint i = 0; i < sequence.size(); i++ ) {
                sequence[i] = right.sequence[i];
            }
        }

        return *this;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq 0x20(%rsp), %rax
jne 0x9fdb
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xa048
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
callq 0x7c40
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xa03c
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x87d0
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x8700
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x9fe3
jmp 0xa03e
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
leaq 0x41f3(%rip), %rsi      # 0xe2c0
xorl %eax, %eax
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3080
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3430
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x3320
jmp 0xa103
leaq 0x3f(%rsp), %rdi
callq 0x32c0
movq 0x10(%rsp), %rax
testb $0x1, 0x80(%rax)
je 0xa1ac
movq 0x10(%rsp), %rax
testb $0x1, 0x81(%rax)
je 0xa18b
movq (%rsp), %rdi
leaq 0x41a1(%rip), %rsi      # 0xe2d9
leaq 0x40(%rsp), %rdx
callq 0x5940
jmp 0xa144
movl $0x1, 0x28(%rsp)
jmp 0xa1fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x32c0
jmp 0xa211
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x31b0
jmp 0xa211
movq (%rsp), %rdi
leaq 0x4158(%rip), %rsi      # 0xe2ee
leaq 0x40(%rsp), %rdx
callq 0x5940
jmp 0xa1a2
movl $0x1, 0x28(%rsp)
jmp 0xa1fa
movq 0x10(%rsp), %rax
testb $0x1, 0x81(%rax)
je 0xa1db
movq (%rsp), %rdi
leaq 0x413e(%rip), %rsi      # 0xe303
leaq 0x40(%rsp), %rdx
callq 0x5940
jmp 0xa1d1
movl $0x1, 0x28(%rsp)
jmp 0xa1fa
movq (%rsp), %rdi
leaq 0x412f(%rip), %rsi      # 0xe315
leaq 0x40(%rsp), %rdx
callq 0x5940
jmp 0xa1f2
movl $0x1, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x31b0
movq 0x8(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3420
nopl (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x9e80
movq 0x60(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x60(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0xad95
leaq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x4(%rax), %eax
movl 0xc(%rsp), %ecx
movq 0x60(%rsp), %rdx
subl (%rdx), %ecx
subl %ecx, %eax
movslq %eax, %rsi
callq 0x8700
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x8700
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xad3d
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0xa060
movq (%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movl %edx, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0xb4(%rsp), %edx
movl 0xb0(%rsp), %ecx
leaq 0x3285(%rip), %rsi      # 0xe344
xorl %eax, %eax
leaq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3080
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3430
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x3320
jmp 0xb0f5
leaq 0x4f(%rsp), %rdi
callq 0x32c0
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x50(%rsp), %rsi
callq 0xb3d0
movq %rax, (%rsp)
jmp 0xb118
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x48, %rdi
callq 0xb410
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xb3b0
testb $0x1, %al
jne 0xb149
jmp 0xb18f
movb $0x1, 0xc7(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0xb19f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x32c0
jmp 0xb1ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x31b0
jmp 0xb1ba
movb $0x0, 0xc7(%rsp)
movl $0x1, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x31b0
movb 0xc7(%rsp), %al
andb $0x1, %al
addq $0xc8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: EduBic[P]TSP-MetaheuristicSolvers/TabuSearchSolver.cpp
// Function: TabuSearchSolver::satisfiedAspirationCriteria(double) const
bool TabuSearchSolver::satisfiedAspirationCriteria(double neighbourCostVariation) const {
    if (ACmode) {
        // aspiration criteria implementation
        //std::cout << std::endl << "Aspiration criteria";
        return neighbourCostVariation < (mAspiration - 0.01);
    } else {
        return false; // default implementation
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
testb $0x1, 0x80(%rax)
je 0xb219
movq -0x20(%rsp), %rax
movsd -0x18(%rsp), %xmm1
movsd 0x78(%rax), %xmm0
movsd 0x30b2(%rip), %xmm2     # 0xe2b8
subsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0xb21e
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nop
// File: EduBic[P]TSP-MetaheuristicSolvers/./LocalSearchSolver.h
// Function: LocalSearchSolver::LocalSearchSolver(bool)
LocalSearchSolver(bool bestImprovement = true) {
        if (bestImprovement) {
            findNeighbor = new BestImprovement();
        } else {
            findNeighbor = new FirstImprovement();
        }
    }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd4a0
movq 0x10(%rsp), %rax
leaq 0x694b(%rip), %rcx      # 0x13c68
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0x1f(%rsp)
je 0xd363
movl $0x8, %edi
callq 0x3290
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x3160
movq 0x8(%rsp), %rdi
callq 0xd4c0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xd396
movl $0x8, %edi
callq 0x3290
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x3160
movq (%rsp), %rdi
callq 0xd4f0
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: DavidNKraemer[P]convex-hull/./cvhull/_Interface.h
// Function: ams562::loadtxt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<ams562::Point2D, std::allocator<ams562::Point2D>>&)
void loadtxt(const std::string &filename, std::vector<Point2D> &p) {
    // check the size, if not zero, make it zero
    if (p.size())
      p.resize(0);

    std::ifstream infile(filename);
    if (infile.is_open()) {
      Point2D temp;
      while (infile >> temp)
        p.push_back(temp);
      infile.close();
    }
    else {

      std::string err = "[Error] Cannot open: " + filename + " to read!";
      throw err;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4030
cmpq $0x0, %rax
je 0x355f
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4050
movq -0x8(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movq %rdi, -0x280(%rbp)
movl $0x8, %edx
callq 0x32f0
movq -0x280(%rbp), %rdi
callq 0x32e0
movb %al, -0x271(%rbp)
jmp 0x358f
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x359e
jmp 0x3632
leaq -0x22c(%rbp), %rdi
callq 0x40e0
jmp 0x35ac
jmp 0x35ae
leaq -0x218(%rbp), %rdi
leaq -0x22c(%rbp), %rsi
callq 0x4100
movq %rax, -0x288(%rbp)
jmp 0x35ca
movq -0x288(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3270
movb %al, -0x289(%rbp)
jmp 0x35e8
movb -0x289(%rbp), %al
testb $0x1, %al
jne 0x35f4
jmp 0x361f
movq -0x10(%rbp), %rdi
leaq -0x22c(%rbp), %rsi
callq 0x4150
jmp 0x3606
jmp 0x35ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x3712
leaq -0x218(%rbp), %rdi
callq 0x3050
jmp 0x362d
jmp 0x36fd
movq -0x8(%rbp), %rdx
leaq 0x49c7(%rip), %rsi      # 0x8004
leaq -0x270(%rbp), %rdi
callq 0x4210
jmp 0x364b
leaq 0x49c8(%rip), %rdx      # 0x801a
leaq -0x250(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x41c0
jmp 0x3667
leaq -0x270(%rbp), %rdi
callq 0x33b8
movq 0x8946(%rip), %rax      # 0xbfc0
movq %rax, -0x298(%rbp)
movl $0x20, %edi
callq 0x30d0
movq %rax, %rdi
movq %rdi, -0x2a0(%rbp)
leaq -0x250(%rbp), %rsi
callq 0x3110
movq -0x2a0(%rbp), %rdi
movq -0x298(%rbp), %rdx
leaq 0x8662(%rip), %rsi      # 0xbd18
callq 0x3310
jmp 0x372a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x33b8
jmp 0x3712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x33b8
jmp 0x3712
leaq -0x218(%rbp), %rdi
callq 0x3060
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x3060
movq -0x220(%rbp), %rdi
callq 0x3340
nopw (%rax,%rax)
// File: DavidNKraemer[P]convex-hull/./cvhull/_Interface.h
// Function: ams562::write2txt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<ams562::Point2D, std::allocator<ams562::Point2D>> const&)
void write2txt(const std::string &filename, const std::vector<Point2D> &p) {
    std::ofstream outfile(filename);
    if (outfile.is_open()) {
      for (const auto & pt : p)
        outfile << pt << '\n';
      outfile.close();
    }
    else {
      std::string err = "[Error] Cannot open: " + filename + " to write!";
      throw err;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movq %rdi, -0x290(%rbp)
movl $0x10, %edx
callq 0x3380
movq -0x290(%rbp), %rdi
callq 0x3160
movb %al, -0x281(%rbp)
jmp 0x3773
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x3782
jmp 0x3848
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
callq 0x4320
movq %rax, -0x230(%rbp)
movq -0x228(%rbp), %rdi
callq 0x4350
movq %rax, -0x238(%rbp)
leaq -0x230(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x4380
testb $0x1, %al
jne 0x37cc
jmp 0x3835
leaq -0x230(%rbp), %rdi
callq 0x43c0
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x43e0
movq %rax, -0x298(%rbp)
jmp 0x37fb
movq -0x298(%rbp), %rdi
movl $0xa, %esi
callq 0x3240
jmp 0x380e
jmp 0x3810
leaq -0x230(%rbp), %rdi
callq 0x4430
jmp 0x37b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x3928
leaq -0x210(%rbp), %rdi
callq 0x3290
jmp 0x3843
jmp 0x3913
movq -0x8(%rbp), %rdx
leaq 0x47b1(%rip), %rsi      # 0x8004
leaq -0x280(%rbp), %rdi
callq 0x4210
jmp 0x3861
leaq 0x47bc(%rip), %rdx      # 0x8024
leaq -0x260(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x41c0
jmp 0x387d
leaq -0x280(%rbp), %rdi
callq 0x33b8
movq 0x8730(%rip), %rax      # 0xbfc0
movq %rax, -0x2a0(%rbp)
movl $0x20, %edi
callq 0x30d0
movq %rax, %rdi
movq %rdi, -0x2a8(%rbp)
leaq -0x260(%rbp), %rsi
callq 0x3110
movq -0x2a8(%rbp), %rdi
movq -0x2a0(%rbp), %rdx
leaq 0x844c(%rip), %rsi      # 0xbd18
callq 0x3310
jmp 0x3940
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x33b8
jmp 0x3928
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x33b8
jmp 0x3928
leaq -0x210(%rbp), %rdi
callq 0x32b0
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x32b0
movq -0x218(%rbp), %rdi
callq 0x3340
// File: DavidNKraemer[P]convex-hull/cvhull/GrahamScan.cpp
// Function: ams562::is_lower(ams562::Point2D, ams562::Point2D)
bool is_lower(Point2D p1, Point2D p2) {
    if (p1.y() == p2.y()) 
      return p1.x() < p2.x();
    else 
      return p1.y() < p2.y();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x7050
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
callq 0x7050
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jne 0x5af8
movq -0x30(%rbp), %rdi
callq 0x7070
movq -0x28(%rbp), %rdi
movl %eax, -0x34(%rbp)
callq 0x7070
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5b1c
movq -0x30(%rbp), %rdi
callq 0x7050
movq -0x28(%rbp), %rdi
movl %eax, -0x38(%rbp)
callq 0x7050
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./shared_ptr.h
// Function: cplusplus_primer::shared_ptr<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::operator=(cplusplus_primer::shared_ptr<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
inline shared_ptr<T>& shared_ptr<T>::operator=(const shared_ptr& rhs)
{
	// increment rhs.refCount first to ensure safty when self-assignment
	++*rhs.refCount;

	// for lhs:
	decrement_n_destroy();

	// copy datastructure from rhs to this.
	ptr = rhs.ptr;
	refCount = rhs.refCount;
	deleter  = rhs.deleter;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x3190
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x3210
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./shared_ptr.h
// Function: cplusplus_primer::shared_ptr<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::decrement_n_destroy()
inline void shared_ptr<T>::decrement_n_destroy()
{
	if (ptr != nullptr) {
		if (--*refCount == 0) {
			delete refCount;
			deleter(ptr);
		}
		refCount = nullptr;
		ptr = nullptr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x3208
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rax
addq $-0x1, %rax
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x31f5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x31e2
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq (%rax), %rsi
callq 0x3260
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: wichtounet[P]articles/src/intrusive_list/bench.cpp
// Function: void (anonymous namespace)::bench_all<Normal<8u>, Normal<32u>, Normal<128u>, Normal<1024u>>()
void bench_all(){
    bench_types<bench_destruction,      Types...>();
    bench_types<bench_sort,             Types...>();
    bench_types<bench_reverse,          Types...>();
    bench_types<bench_fill_back,        Types...>();
    bench_types<bench_linear_search,    Types...>();
    bench_types<bench_write,            Types...>();
    bench_types<bench_iterate,          Types...>();
    bench_types<bench_random_insert,    Types...>();
}

// Assembly:
pushq %rax
callq 0x4fb0
callq 0x4fc0
callq 0x4fd0
callq 0x4fe0
callq 0x4ff0
callq 0x5000
callq 0x5010
callq 0x5020
popq %rax
retq
nopl (%rax,%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: BackupSmartFilled<boost::intrusive::list<Intrusive<8u, (boost::intrusive::link_mode_type)0>, 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:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x8b33e(%rip), %rdi     # 0x9d1f0
callq 0x120c0
cmpq 0x68(%rsp), %rax
je 0x11f54
leaq 0x8b327(%rip), %rdi     # 0x9d1f0
callq 0x120e0
movq 0x68(%rsp), %rsi
leaq 0x8b316(%rip), %rdi     # 0x9d1f0
callq 0x12100
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x68(%rsp), %rax
jae 0x11f52
movq 0x60(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x12270
movq 0x18(%rsp), %rsi
leaq 0x8b2dc(%rip), %rdi     # 0x9d1f0
callq 0x12240
jmp 0x11f1b
leaq 0x48(%rsp), %rdi
callq 0xf9f0
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x11ee8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xf9f0
jmp 0x1202e
jmp 0x11f54
movb $0x0, 0x3b(%rsp)
movl $0x10, %edi
callq 0x3200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x122d0
jmp 0x11f75
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x122e0
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x68(%rsp), %rax
jae 0x1200e
movq 0x20(%rsp), %rdi
callq 0x12310
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x8b23c(%rip), %rdi     # 0x9d1f0
callq 0x12380
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x12320
jmp 0x11fc8
jmp 0x11fca
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x11f8d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x31e0
jmp 0x1202e
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x12040
jmp 0x1202e
movb $0x1, 0x3b(%rsp)
testb $0x1, 0x3b(%rsp)
jne 0x12024
movq 0x20(%rsp), %rdi
callq 0x12040
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x3340
nopl (%rax,%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: EmptyPrepareBackup<boost::intrusive::list<Intrusive<8u, (boost::intrusive::link_mode_type)0>, boost::intrusive::constant_time_size<false>>>::make(unsigned long)
inline static 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});
            }
        }

        return Container();
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
leaq 0x4c57e(%rip), %rdi     # 0x9d590
callq 0x120c0
cmpq 0x48(%rsp), %rax
je 0x510af
leaq 0x4c567(%rip), %rdi     # 0x9d590
callq 0x120e0
movq 0x48(%rsp), %rsi
leaq 0x4c556(%rip), %rdi     # 0x9d590
callq 0x12100
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x510ad
movq 0x40(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x12270
movq (%rsp), %rsi
leaq 0x4c51e(%rip), %rdi     # 0x9d590
callq 0x12240
jmp 0x51079
leaq 0x28(%rsp), %rdi
callq 0xf9f0
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x51048
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf9f0
jmp 0x510c3
jmp 0x510af
movq 0x8(%rsp), %rdi
callq 0x122d0
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x3340
nopl (%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: Iterate<std::__cxx11::list<Normal<8u>, std::allocator<Normal<8u>>>>::run(std::__cxx11::list<Normal<8u>, std::allocator<Normal<8u>>>&, unsigned long)
inline static void run(Container &c, std::size_t){
        auto it = std::begin(c);
        auto end = std::end(c);

        while(it != end){
            ++it;
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x54aa0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x54ad0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x33710
testb $0x1, %al
jne 0x5df91
jmp 0x5df9d
leaq 0x10(%rsp), %rdi
callq 0x33380
jmp 0x5df7c
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/c++11/test-1.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	std::unordered_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		auto p = h.emplace(get_key(n, x), 0);
		z += ++p.first->second;
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0xa8, %rsp
movl %edi, 0xa4(%rsp)
movl %esi, 0xa0(%rsp)
movl $0x0, 0x94(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x17c0
movl $0x0, 0x9c(%rsp)
movl 0xa0(%rsp), %eax
movl %eax, 0x98(%rsp)
movl 0x9c(%rsp), %eax
cmpl 0xa4(%rsp), %eax
jae 0x1744
movl 0x98(%rsp), %edi
callq 0x12b0
movl %eax, 0x1c(%rsp)
jmp 0x1679
movl 0x1c(%rsp), %eax
movl %eax, 0x98(%rsp)
movl 0xa4(%rsp), %edi
movl 0x98(%rsp), %esi
callq 0x1320
movl %eax, 0x18(%rsp)
jmp 0x169d
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x34(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x17d0
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x16cc
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movb %al, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movb 0x28(%rsp), %al
movb %al, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1820
movq %rax, %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
addl 0x94(%rsp), %eax
movl %eax, 0x94(%rsp)
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rsp)
jmp 0x1653
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1850
jmp 0x179c
movq 0x4895(%rip), %rax      # 0x5fe0
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1840
movq (%rsp), %rdi
movq %rax, %rdx
movl 0x94(%rsp), %ecx
leaq 0x1908(%rip), %rsi      # 0x3079
movb $0x0, %al
callq 0x10f0
leaq 0x58(%rsp), %rdi
callq 0x1840
movl %eax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1850
movl 0x8(%rsp), %eax
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/rsort.c
// Function: keyscan
static void
keyscan(int pos, RANGE const *srcv, int nsrcs,
        PARTNO mdata[][256], PARTNO ** mapv)
{
    int i, j;
    uint8_t buf[SCANWID];

    // Allocate [SCANWID] mdata vectors 
    for (i = j = 0; i < SCANWID; ++j) {
        if (*mdata[j] == UNUSED) {
            memset(mdata[j], 0, sizeof(mdata[0]));
            mapv[pos + i++] = mdata[j];
        }
    }

    for (i = 0; i < nsrcs; ++i) {
        RSREC **rpp = srcv[i].alpha;

        for (; rpp != srcv[i].omega; ++rpp) {
            j = imin(SCANWID, KEYLENG(*rpp) - pos);
            uint8_t const *dp = KEYDATA(*rpp, pos, j, buf);
            while (--j >= 0)
                mapv[pos + j][dp[j]] = 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x10, -0x2c(%rbp)
jge 0x69e7
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
cmpl $0x109d1, (%rax)        # imm = 0x109D1
jne 0x69da
movq -0x20(%rbp), %rdi
movslq -0x30(%rbp), %rax
shlq $0xa, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x30f0
movq -0x20(%rbp), %rdx
movslq -0x30(%rbp), %rax
shlq $0xa, %rax
addq %rax, %rdx
movq -0x28(%rbp), %rax
movl -0x4(%rbp), %ecx
movl -0x2c(%rbp), %esi
movl %esi, %edi
addl $0x1, %edi
movl %edi, -0x2c(%rbp)
addl %esi, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x69dc
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6978
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6ab8
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
je 0x6aa8
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x6260
movl %eax, %esi
subl -0x4(%rbp), %esi
movl $0x10, %edi
callq 0x6ac0
movl %eax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x30(%rbp), %edx
leaq -0x40(%rbp), %rcx
callq 0x6af0
movq %rax, -0x50(%rbp)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
jl 0x6a95
movq -0x28(%rbp), %rax
movl -0x4(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq -0x50(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movl $0x1, (%rax,%rcx,4)
jmp 0x6a61
jmp 0x6a97
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
jmp 0x6a10
jmp 0x6aaa
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x69ee
addq $0x50, %rsp
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/rsort.c
// Function: insort
static void
insort(RSREC ** alpha, RSREC ** omega, int pos)
{
    RSREC **rpp = alpha;

    while (++rpp != omega) {
        RSREC **qpp, *rp = *rpp;
        int rlen = KEYLENG(rp) - pos;

        for (qpp = rpp; --qpp >= alpha; qpp[1] = qpp[0]) {
            int qlen = KEYLENG(*qpp) - pos;
            int rc = KEYDIFF(*qpp, rp, pos, imin(rlen, qlen));
            if (rc < 0 || (rc == 0 && qlen <= rlen))
                break;
        }

        qpp[1] = rp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
cmpq -0x10(%rbp), %rax
je 0x6c0d
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6260
subl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x28(%rbp)
cmpq -0x8(%rbp), %rax
jb 0x6bfc
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x6260
subl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x34(%rbp), %edi
movl -0x38(%rbp), %esi
callq 0x6ac0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x40(%rbp), %edx
movl %eax, %ecx
callq 0x6c20
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0x6be4
cmpl $0x0, -0x3c(%rbp)
jne 0x6be6
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jg 0x6be6
jmp 0x6bfc
jmp 0x6be8
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x6b73
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x6b3b
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH05_Statements/examples/vowels.cc
// Function: main
int main()
{
    // initialize counters for each vowel
    unsigned aCnt = 0, eCnt = 0, iCnt = 0, oCnt = 0, uCnt = 0;

    char ch;
    while (cin >> ch) {
    	// if ch is a vowel, increment the appropriate counter
    	switch (ch) {
    		case 'a':
    			++aCnt;
    			break;
    		case 'e':
    			++eCnt;
    			break;
    		case 'i':
    			++iCnt;
    			break;
    		case 'o':
    			++oCnt;
    			break;
    		case 'u':
    			++uCnt;
    			break;
    	}
    }
    // print results
    cout << "Number of vowel a: \t" << aCnt << '\n'
         << "Number of vowel e: \t" << eCnt << '\n'
         << "Number of vowel i: \t" << iCnt << '\n'
         << "Number of vowel o: \t" << oCnt << '\n'
         << "Number of vowel u: \t" << uCnt << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq 0x2db7(%rip), %rdi      # 0x3fe0
leaq -0x19(%rbp), %rsi
callq 0x1080
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1070
testb $0x1, %al
jne 0x1247
jmp 0x12a7
movsbl -0x19(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x14, %eax
ja 0x12a2
movq -0x28(%rbp), %rax
leaq 0xda0(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x12a2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12a2
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12a2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12a2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1222
movq 0x2d22(%rip), %rdi      # 0x3fd0
leaq 0xda3(%rip), %rsi       # 0x2058
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1090
movq %rax, %rdi
movl $0xa, %esi
callq 0x1060
movq %rax, %rdi
leaq 0xd91(%rip), %rsi       # 0x206d
callq 0x1040
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1090
movq %rax, %rdi
movl $0xa, %esi
callq 0x1060
movq %rax, %rdi
leaq 0xd7f(%rip), %rsi       # 0x2082
callq 0x1040
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x1090
movq %rax, %rdi
movl $0xa, %esi
callq 0x1060
movq %rax, %rdi
leaq 0xd6d(%rip), %rsi       # 0x2097
callq 0x1040
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1090
movq %rax, %rdi
movl $0xa, %esi
callq 0x1060
movq %rax, %rdi
leaq 0xd5b(%rip), %rsi       # 0x20ac
callq 0x1040
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x1090
movq %rax, %rdi
movq 0x2c55(%rip), %rsi      # 0x3fc0
callq 0x1050
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %ecx
leaq 0xfd10(%rip), %rax      # 0x14248
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
leaq 0xfd08(%rip), %rax      # 0x1424c
movl %ecx, (%rax)
leaq 0xfcfb(%rip), %rax      # 0x14248
movl (%rax), %eax
leaq 0xfcf6(%rip), %rcx      # 0x1424c
imull (%rcx), %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
leaq 0xfcb2(%rip), %rax      # 0x14238
movq %rcx, (%rax)
leaq 0xfcb8(%rip), %rax      # 0x14248
movl (%rax), %eax
leaq 0xfcb3(%rip), %rcx      # 0x1424c
imull (%rcx), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
leaq 0xfc77(%rip), %rax      # 0x14240
movq %rcx, (%rax)
callq 0x45e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xfb95(%rip), %rax      # 0x14180
movsd 0x9a4d(%rip), %xmm0     # 0xe040
movsd %xmm0, (%rax)
leaq 0xfb82(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
leaq 0xfb73(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
leaq 0xfb64(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
leaq 0xfb55(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
leaq 0xfb46(%rip), %rax      # 0x14180
movsd 0x99fe(%rip), %xmm0     # 0xe040
movsd %xmm0, 0x28(%rax)
leaq 0xfb32(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
leaq 0xfb23(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rax)
leaq 0xfb14(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rax)
leaq 0xfb05(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rax)
leaq 0xfaf6(%rip), %rax      # 0x14180
movsd 0x99ae(%rip), %xmm0     # 0xe040
movsd %xmm0, 0x50(%rax)
leaq 0xfae2(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x58(%rax)
leaq 0xfad3(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
leaq 0xfac4(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rax)
leaq 0xfab5(%rip), %rax      # 0x14180
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rax)
leaq 0xfaa6(%rip), %rax      # 0x14180
movsd 0x995e(%rip), %xmm0     # 0xe040
movsd %xmm0, 0x78(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm5, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
leaq 0xfae2(%rip), %rax      # 0x14200
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
leaq 0xfada(%rip), %rax      # 0x14208
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
leaq 0xfad2(%rip), %rax      # 0x14210
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
leaq 0xfaca(%rip), %rax      # 0x14218
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
leaq 0xfac2(%rip), %rax      # 0x14220
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
leaq 0xfaba(%rip), %rax      # 0x14228
movsd %xmm0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myTranslated(double, double, double)
void myTranslated(double x, double y, double z){
    double matrix[4][4], omatrix[4][4];
    matrix[0][0] = 1; matrix[0][1] = 0; matrix[0][2] = 0; matrix[0][3] = x;
    matrix[1][0] = 0; matrix[1][1] = 1; matrix[1][2] = 0; matrix[1][3] = y;
    matrix[2][0] = 0; matrix[2][1] = 0; matrix[2][2] = 1; matrix[2][3] = z;
    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
subq $0x130, %rsp            # imm = 0x130
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd 0x93ce(%rip), %xmm0     # 0xe040
movsd %xmm0, -0xa0(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x98(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x88(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x80(%rbp)
movsd 0x9393(%rip), %xmm0     # 0xe040
movsd %xmm0, -0x78(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x9364(%rip), %xmm0     # 0xe040
movsd %xmm0, -0x50(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x9335(%rip), %xmm0     # 0xe040
movsd %xmm0, -0x28(%rbp)
leaq -0xa0(%rbp), %rsi
leaq -0x120(%rbp), %rdx
leaq 0xf45b(%rip), %rdi      # 0x14180
callq 0x9c60
movl $0x0, -0x124(%rbp)
cmpl $0x4, -0x124(%rbp)
jge 0x4db9
movl $0x0, -0x128(%rbp)
cmpl $0x4, -0x128(%rbp)
jge 0x4da3
movslq -0x124(%rbp), %rcx
leaq -0x120(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x128(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movslq -0x124(%rbp), %rcx
leaq 0xf401(%rip), %rax      # 0x14180
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x128(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x128(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x128(%rbp)
jmp 0x4d47
jmp 0x4da5
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0x4d34
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)