LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/drofp[P]RoadRun/src/settings_menu.cc
// Function: roadrun::SettingsMenu::PrintMenu()
void SettingsMenu::PrintMenu()
  {
    endwin();
    refresh();
    WINDOW *menu_win;
    int highlight = 1;
    int choice = 0;
    int c;
    initscr();
    clear();
    noecho();
    cbreak();
    int startx = 5;  // (80 - kWidth) / 2;
    int starty = 5;  // (80 - kHeight) / 2;
    menu_win = newwin(kHeight, kWidth, starty, startx);
    keypad(menu_win, TRUE);
    mvprintw(0, 0, "Use up and down arrows to choose, enter to select.");
    refresh();
    RenderOptions(menu_win, highlight);
    int enter_pressed = 0;
    while(!enter_pressed)
    {
      c = wgetch(menu_win);
      switch (c)
      {
      case KEY_UP:
        if(highlight == 1)
            highlight = 2;
          else
            --highlight;
          break;
      case KEY_DOWN:
        if(highlight == 2)
          highlight = 1;
        else
          ++highlight;
        break;
      case 10:
        choice = highlight;
        enter_pressed = 1;
        break;
      default:
        // mvprintw(24, 0, "Charcter pressed is = %3d Hopefully it can be printed as '%c'", c, c);
        refresh();
        break;
      }
      current_choice = settings_item_list[highlight - 1];
      RenderOptions(menu_win, highlight);
    }
    // mvprintw(23, 0, "You chose choice %d with choice string %s\n", choice, choices[choice - 1]);
    clrtoeol();
    refresh();
    endwin();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21d0
callq 0x2260
callq 0x2230
callq 0x2270
callq 0x21c0
callq 0x2070
movl 0x14(%rbx), %esi
movl 0x18(%rbx), %edi
pushq $0x5
popq %rcx
movl %ecx, %edx
callq 0x2170
movq %rax, %r14
pushq $0x1
popq %r12
movq %rax, %rdi
movl %r12d, %esi
callq 0x20a0
leaq 0xd07(%rip), %rdx       # 0x45bb
xorl %r15d, %r15d
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2200
callq 0x2260
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq *0x10(%rax)
leaq 0xfa3(%rip), %r13       # 0x4880
testl %r15d, %r15d
jne 0x3947
movq %r14, %rdi
callq 0x2090
cmpl $0xa, %eax
je 0x391b
cmpl $0x102, %eax            # imm = 0x102
je 0x3908
cmpl $0x103, %eax            # imm = 0x103
jne 0x3921
xorl %eax, %eax
cmpl $0x1, %r12d
sete %al
jmp 0x3911
xorl %eax, %eax
cmpl $0x2, %r12d
setne %al
incl %eax
xorl %r15d, %r15d
movl %eax, %r12d
jmp 0x3929
pushq $0x1
popq %r15
jmp 0x3929
callq 0x2260
xorl %r15d, %r15d
leal -0x1(%r12), %eax
movl (%r13,%rax,4), %eax
movl %eax, 0x10(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq *0x10(%rax)
jmp 0x38dd
movq 0x368a(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
callq 0x21a0
callq 0x2260
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/ajuc[P]c--_lisp_sexp_parser/test_parse.cpp
// Function: main
int main(int argc, char* argv[]) {
	std::string tmp(argv[1]);
	std::istringstream input(tmp);
	const std::shared_ptr<const AjucLispParser::Expression> e = AjucLispParser::parse(input);
	std::cout << e->toString() << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %rbx
leaq -0x1e0(%rbp), %rdx
movq %rbx, %rdi
callq 0x3080
leaq -0x1e0(%rbp), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x3260
leaq -0x30(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x3c19
leaq -0x28(%rbp), %rdi
movq -0x8(%rdi), %r14
movq (%rdi), %rax
leaq -0x58(%rbp), %rbx
movq %r14, -0x8(%rbx)
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rdi)
callq 0x353e
movq (%r14), %rax
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq 0x6b17(%rip), %rdi      # 0x9fd0
leaq -0x30(%rbp), %rsi
callq 0x3140
movq %rax, %rdi
callq 0x30d0
leaq -0x30(%rbp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x353e
leaq -0x1e0(%rbp), %rdi
callq 0x30c0
leaq -0x50(%rbp), %rdi
callq 0x30b0
xorl %eax, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0x3519
movq %rax, %r14
jmp 0x3521
movq %rax, %r14
jmp 0x352d
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x353e
leaq -0x1e0(%rbp), %rdi
callq 0x30c0
leaq -0x50(%rbp), %rdi
callq 0x30b0
movq %r14, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/ajuc[P]c--_lisp_sexp_parser/lispparser.cpp
// Function: AjucLispParser::Float::Float(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Float::Float(const std::string& text) {
	std::istringstream ss(text);
	float f;
	ss >> f;
	(this->_value) = f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x649c(%rip), %rax      # 0x9aa0
movq %rax, (%rdi)
leaq -0x198(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x3260
leaq -0x14(%rbp), %rsi
movq %r14, %rdi
callq 0x32c0
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x8(%rbx)
leaq -0x198(%rbp), %rdi
callq 0x30c0
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x198(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/ajuc[P]c--_lisp_sexp_parser/lispparser.cpp
// Function: AjucLispParser::List::toString[abi:cxx11]() const
const std::string List::toString() const {
	std::string result("( ");
	for (unsigned int i=0; i<elements.size(); i++) {
		if (i>0) {
			result += ", ";
		}
		result = result + elements[i]->toString();
	}
	result += " )";
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x264e(%rip), %rsi      # 0x6006
leaq -0x68(%rbp), %r15
movq %r15, %rdx
callq 0x3080
xorl %r13d, %r13d
leaq -0x48(%rbp), %r12
movl %r13d, %r13d
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r13, %rcx
jbe 0x3a3c
testq %r13, %r13
je 0x39fa
movq %rbx, %rdi
leaq 0x2618(%rip), %rsi      # 0x6009
callq 0x3290
movq 0x8(%r14), %rax
movq %r13, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x44ad
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31c0
movq %r15, %rdi
callq 0x30b0
movq %r12, %rdi
callq 0x30b0
incl %r13d
jmp 0x39cb
leaq 0x25c9(%rip), %rsi      # 0x600c
movq %rbx, %rdi
callq 0x3290
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a6f
jmp 0x3a6f
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x30b0
jmp 0x3a72
movq %rax, %r14
movq %rbx, %rdi
callq 0x30b0
movq %r14, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::mapLF(SideLocus const&) const
inline int Ebwt::rowL(const SideLocus& l) const {
	// Extract and return appropriate bit-pair
#ifdef SIXTY4_FORMAT
	return (((uint64_t*)l.side(this->_ebwt))[l._by >> 3] >> ((((l._by & 7) << 2) + l._bp) << 1)) & 3;
#else
	return unpack_2b_from_8b(l.side(this->_ebwt)[l._by], l._bp);
#endif
}

// Assembly:
movq 0xc8(%rdi), %rax
addq (%rsi), %rax
movswq 0x14(%rsi), %rcx
movzbl (%rcx,%rax), %edx
movb 0x16(%rsi), %cl
addb %cl, %cl
shrl %cl, %edx
andl $0x3, %edx
cmpb $0x1, 0x12(%rsi)
jne 0x17820
cmpb $0x0, 0x1c1(%rdi)
je 0x17722
jmp 0x177ac
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: ChunkPool::reset(SStringExpandable<char, 25, 2, 0>*, unsigned int)
void reset(BTString* name, uint32_t patid_) {
		patid = patid_;
		readName_ = name;
		cur_ = 0;
		bits_.clear();
		assert_eq(0, bits_.test(0));
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %edx, 0x4(%rdi)
movq %rsi, 0x48(%rdi)
andl $0x0, 0x10(%rdi)
movq 0x20(%rdi), %rax
movq 0x38(%rdi), %rdi
shrq $0x6, %rax
leaq 0x8(,%rax,8), %rdx
xorl %esi, %esi
callq 0x9270
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./random_source.h
// Function: RandomSource::nextU64()
uint64_t nextU64() {
		assert(inited_);
		uint64_t first = nextU32();
		first = first << 32;
		uint64_t second = nextU32();
		return first | second;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2699e
movl %eax, %r14d
shlq $0x20, %r14
movq %rbx, %rdi
callq 0x2699e
movl %eax, %eax
orq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/EduBic[P]TSP-MetaheuristicSolvers/solversexecutor.cpp
// Function: SolversExecutor::executeAndMeasureTime(Solver&, TSPSolution&, TSPSolution&)
void SolversExecutor::executeAndMeasureTime(Solver& tspSolver, TSPSolution& initSol, TSPSolution& bestSol) {

    bestSol.solveBy = tspSolver.getSolverName();

    std::string tmp = "-----------------------------";
    std::cout << std::endl << tmp << tspSolver.getSolverName() << tmp << std::endl << std::endl;

    // initialize clocks for running time recording
    //   two ways:
    //   1) CPU time (t2 - t1)
    //   2) wall-clock time (tv2 - tv1)
    clock_t startClock, finishClock;
    timeval  tv1, tv2;

    startClock = clock();
    gettimeofday(&tv1, NULL);

    tspSolver.solve(mTspInstance, initSol, bestSol);

    finishClock = clock();
    gettimeofday(&tv2, NULL);

    bestSol.userTime = (double)(tv2.tv_sec+tv2.tv_usec*1e-6 - (tv1.tv_sec+tv1.tv_usec*1e-6));
    bestSol.cpuTime = (double)(finishClock - startClock) / CLOCKS_PER_SEC;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rax
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq *(%rax)
leaq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0x3290
movq %r13, %rdi
callq 0x3120
leaq 0x333a(%rip), %rsi      # 0x716d
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30f0
movq 0x7189(%rip), %rdi      # 0xafd0
callq 0x3130
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x3210
movq %rax, %r13
movq (%r15), %rax
movq %rsp, %rdi
movq %r15, %rsi
callq *(%rax)
movq %rsp, %rsi
movq %r13, %rdi
callq 0x3210
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x3210
movq %rax, %rdi
callq 0x3130
movq %rax, %rdi
callq 0x3130
movq %rsp, %rdi
callq 0x3120
callq 0x31a0
movq %rax, %r13
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3330
addq $0x8, %r12
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x8(%rax)
callq 0x31a0
movq %rax, %r14
leaq 0x40(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3330
cvtsi2sdq (%r15), %xmm0
cvtsi2sdq 0x8(%r15), %xmm1
movsd 0x313f(%rip), %xmm2     # 0x7028
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdq (%rsp), %xmm0
cvtsi2sdq 0x8(%rsp), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
subsd %xmm3, %xmm1
subq %r13, %r14
cvtsi2sd %r14, %xmm0
movsd %xmm1, 0x38(%rbx)
divsd 0x3111(%rip), %xmm0     # 0x7030
movsd %xmm0, 0x40(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x3120
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3f40
jmp 0x3f40
movq %rax, %rbx
jmp 0x3f50
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3120
leaq 0x20(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O2/EduBic[P]TSP-MetaheuristicSolvers/solversexecutor.cpp
// Function: SolversExecutor::printInitSolutions() const
void SolversExecutor::printInitSolutions() const {
    for (vector<TSPSolution*>::const_iterator it = mInitSolutions.begin(); it != mInitSolutions.end(); ++it) {
        cout << endl << (*it)->solveBy << endl;
        cout << "(value : " << (*it)->evaluateObjectiveFunction(mTspInstance) << ")\n";
        cout << "sec. (user time) " << (*it)->userTime << endl;
        cout << "sec. (CPU time) " << (*it)->cpuTime << endl;
        cout << "Max iterations " << (*it)->iterations << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r12
leaq 0x8(%rdi), %r14
movq 0x7051(%rip), %r15      # 0xafd0
leaq 0x31a1(%rip), %r13      # 0x7127
cmpq 0x68(%rbx), %r12
je 0x4060
movq %r15, %rdi
callq 0x3130
movq (%r12), %rsi
addq $0x18, %rsi
movq %rax, %rdi
callq 0x3210
movq %rax, %rdi
callq 0x3130
movq %r15, %rdi
leaq 0x313d(%rip), %rsi      # 0x70f7
callq 0x3250
movq %rax, %rbp
movq (%r12), %rdi
movq %r14, %rsi
callq 0x476c
movq %rbp, %rdi
callq 0x3320
movq %rax, %rdi
leaq 0x3157(%rip), %rsi      # 0x7137
callq 0x3250
movq %r15, %rdi
leaq 0x3115(%rip), %rsi      # 0x7104
callq 0x3250
movq (%r12), %rcx
movsd 0x38(%rcx), %xmm0
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x3130
movq %r15, %rdi
leaq 0x30ff(%rip), %rsi      # 0x7116
callq 0x3250
movq (%r12), %rcx
movsd 0x40(%rcx), %xmm0
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x3130
movq %r15, %rdi
movq %r13, %rsi
callq 0x3250
movq (%r12), %rcx
movl 0x48(%rcx), %esi
movq %rax, %rdi
callq 0x31b0
movq %rax, %rdi
callq 0x3130
addq $0x8, %r12
jmp 0x3f86
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/EduBic[P]TSP-MetaheuristicSolvers/./TSP.h
// Function: TSP::readFromFile(char const*)
void readFromFile(const char* filename) {
        std::ifstream in(filename);

        in >> n;
        std::cout << "read from file, num nodes = " << n << std::endl;

        cost.resize(n);
        for (int i = 0; i < n; i++) {

            cost[i].reserve(n);

            for (int j = 0; j < n; j++) {
                double c;
                in >> c;
                cost[i].push_back(c);
            }
        }

        in.close();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x33c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3180
movq 0x6bb0(%rip), %rdi      # 0xafd0
leaq 0x2db6(%rip), %rsi      # 0x71dd
callq 0x3250
movl (%rbx), %esi
movq %rax, %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x3130
leaq 0x8(%rbx), %r14
movslq (%rbx), %rsi
movq %r14, %rdi
callq 0x47ae
movl (%rbx), %eax
xorl %ecx, %ecx
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movslq %eax, %rsi
cmpq %rsi, %rcx
jge 0x44a7
movq %rcx, (%rsp)
imulq $0x18, %rcx, %rbp
movq (%r14), %rdi
addq %rbp, %rdi
callq 0x47e4
xorl %r13d, %r13d
movl (%rbx), %eax
cmpl %eax, %r13d
jge 0x449e
movq %r15, %rdi
movq %r12, %rsi
callq 0x3190
movq (%r14), %rdi
addq %rbp, %rdi
movq %r12, %rsi
callq 0x4874
incl %r13d
jmp 0x4479
movq (%rsp), %rcx
incq %rcx
jmp 0x445b
leaq 0x10(%rsp), %rdi
callq 0x3080
leaq 0x10(%rsp), %rdi
callq 0x30a0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x44d1
jmp 0x44d1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
leaq 0x18(%rdi), %r14
movb $0x0, 0x28(%rdi)
movslq (%rsi), %rsi
incq %rsi
callq 0x4c78
xorl %eax, %eax
movq %rsp, %r12
movl %eax, (%rsp)
cmpl (%r15), %eax
jge 0x453e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4d08
movl (%rsp), %eax
incl %eax
jmp 0x4524
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x4e68
leaq 0x2ce9(%rip), %rsi      # 0x723e
movq %r14, %rdi
callq 0x33e0
movaps 0x2aac(%rip), %xmm0     # 0x7010
movups %xmm0, 0x38(%rbx)
andl $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x457c
jmp 0x457c
movq %rax, %r15
movq %r14, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x4f48
movq %r15, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movabsq $0x100000000, %r15      # imm = 0x100000000
movl %esi, %edi
callq 0x3240
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
pushq $0x1
popq %rbp
subq %rsi, %rcx
movl %ebp, %eax
sarq $0x2, %rcx
cmpq %rax, %rcx
jbe 0x4632
callq 0x30b0
cltq
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x2, %rcx
addq $-0x2, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %r14
callq 0x30b0
cltq
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %rcx, %rdi
subq %rsi, %rdi
sarq $0x2, %rdi
addq $-0x2, %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)
incl %ebp
jmp 0x45bd
movq 0x6997(%rip), %r14      # 0xafd0
leaq 0x2c05(%rip), %r15      # 0x7245
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, %rdi
callq 0x3130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f56
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3130
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rsi), %rdx
xorpd %xmm0, %xmm0
pushq $0x1
popq %rsi
leal -0x1(%rsi), %edi
cmpq %rdi, %rcx
jbe 0x47ad
movslq (%rax,%rdi,4), %rdi
movl %esi, %r8d
movslq (%rax,%r8,4), %r8
imulq $0x18, %rdi, %rdi
movq (%rdx,%rdi), %rdi
addsd (%rdi,%r8,8), %xmm0
incl %esi
jmp 0x4788
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3130
xorl %eax, %eax
leaq 0x21b0(%rip), %r15      # 0x7125
movl %eax, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x4fa9
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x33a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x3250
leal 0x1(%r12), %eax
jmp 0x4f75
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3130
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x5562
movslq (%r14), %rax
movq (%r15), %rcx
movq (%rbx), %rdx
movl %eax, %esi
negl %esi
movslq 0x4(%r14), %rdi
cmpq %rdi, %rax
jg 0x554d
addl (%r14), %edi
addl %esi, %edi
movslq %edi, %rdi
movl (%rcx,%rdi,4), %edi
movl %edi, (%rdx,%rax,4)
incq %rax
decl %esi
jmp 0x552f
movq %rsp, %rdi
callq 0x5640
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x2, %rsi
callq 0x4c78
xorl %r12d, %r12d
movl %r12d, %r12d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x55ca
leaq (%rax,%r12,4), %rsi
movq %rbx, %rdi
callq 0x4d08
incl %r12d
jmp 0x55a3
leaq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x3160
movups 0x38(%r15), %xmm0
movups %xmm0, 0x38(%rbx)
movl 0x48(%r15), %eax
movl %eax, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x55f4
movq %rax, %r15
movq %r14, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x4f48
movq %r15, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
cmpq %rsi, %rdi
je 0x563e
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movq (%rsi), %rsi
xorl %edi, %edi
movl %edi, %edi
cmpq %rdi, %rdx
jbe 0x563e
movl (%rsi,%rdi,4), %r8d
movl %r8d, (%rcx,%rdi,4)
incl %edi
jmp 0x562b
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %edx
movl 0xc(%rsi), %ecx
leaq 0x1c4a(%rip), %rsi      # 0x72c0
leaq 0x30(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3070
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x30f0
leaq 0x1c62(%rip), %rax      # 0x7303
leaq 0x1c6d(%rip), %rcx      # 0x7315
cmpb $0x0, 0x81(%r14)
cmovneq %rax, %rcx
leaq 0x1c1e(%rip), %rax      # 0x72d9
leaq 0x1c2c(%rip), %rsi      # 0x72ee
cmovneq %rax, %rsi
cmpb $0x0, 0x80(%r14)
cmoveq %rcx, %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x46f5
leaq 0x10(%rsp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x5562
movslq (%r14), %rax
movq (%r15), %rcx
movq (%rbx), %rdx
movl %eax, %esi
negl %esi
movslq 0x4(%r14), %rdi
cmpq %rdi, %rax
jg 0x5cbb
addl (%r14), %edi
addl %esi, %edi
movslq %edi, %rdi
movl (%rcx,%rdi,4), %edi
movl %edi, (%rdx,%rax,4)
incq %rax
decl %esi
jmp 0x5c9d
movq %rsp, %rdi
callq 0x5640
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x70, %rsp
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rbx
leaq 0x14cd(%rip), %rsi      # 0x7344
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3070
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x30f0
leaq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x648a
addq $0x50, %rbx
cmpq %rbx, %rax
setne %bl
leaq 0x10(%rsp), %rdi
callq 0x3120
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, -0x8(%rsp)
movsd 0x20(%rsi), %xmm0
movq (%rdx), %rax
movq 0x8(%rdx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
leaq -0x2(%rdx), %rsi
decq %rdx
movl $0x1, %r8d
movapd 0x8b3(%rip), %xmm1      # 0x72b0
movl %r8d, %r9d
cmpq %r9, %rsi
jbe 0x6a90
leal -0x1(%r8), %r10d
movslq (%rax,%r10,4), %rbx
movslq (%rax,%r9,4), %r9
leal 0x1(%r8), %r10d
movq -0x8(%rsp), %rdi
movq 0x8(%rdi), %r11
imulq $0x18, %rbx, %rbx
addq %r11, %rbx
imulq $0x18, %r9, %r14
addq %r11, %r14
movl %r10d, %r15d
movl %r15d, %r15d
cmpq %r15, %rdx
jbe 0x6a88
movslq (%rax,%r15,4), %r12
incl %r15d
movslq (%rax,%r15,4), %r13
movq (%rbx), %rbp
movsd (%rbp,%r9,8), %xmm2
xorpd %xmm1, %xmm2
imulq $0x18, %r12, %rdi
movq (%r11,%rdi), %rdi
subsd (%rdi,%r13,8), %xmm2
addsd (%rbp,%r12,8), %xmm2
movq (%r14), %rdi
addsd (%rdi,%r13,8), %xmm2
ucomisd %xmm2, %xmm0
jbe 0x6a33
movl %r8d, (%rcx)
leal -0x1(%r15), %edi
movl %edi, 0x4(%rcx)
movapd %xmm2, %xmm0
jmp 0x6a33
movl %r10d, %r8d
jmp 0x69fd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x2411
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2a28
leaq 0x48(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x2210
leaq 0xc0(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x2487
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a59
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2466
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a90
jmp 0x2440
leaq 0x48(%rsp), %rdi
callq 0x2040
leaq 0x48(%rsp), %rdi
callq 0x2060
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1b76(%rip), %rsi      # 0x4004
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x2acf
leaq 0x1b78(%rip), %rdx      # 0x401a
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2ab0
leaq 0x28(%rsp), %rdi
callq 0x22a8
pushq $0x20
popq %rdi
callq 0x20c0
leaq 0x10(%rax), %rdx
movq %rdx, (%rax)
leaq 0x18(%rsp), %rcx
movq -0x10(%rcx), %rsi
cmpq %rcx, %rsi
jne 0x24e0
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x24ec
movq %rsi, (%rax)
movq 0x18(%rsp), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rsp), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x383c(%rip), %rsi      # 0x5d48
movq 0x3aad(%rip), %rdx      # 0x5fc0
movq %rax, %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x252d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x22a8
jmp 0x253b
jmp 0x2538
jmp 0x2538
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
pushq $0x10
popq %rdx
movq %rbx, %rsi
callq 0x2280
leaq 0xb8(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x25d2
movq (%r14), %rbx
movq 0x8(%r14), %r15
leaq 0x48(%rsp), %r14
pushq $0xa
popq %rbp
cmpq %r15, %rbx
je 0x25b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b45
movq %rax, %rdi
movl %ebp, %esi
callq 0x2170
addq $0x8, %rbx
jmp 0x2590
leaq 0x48(%rsp), %rdi
callq 0x21c0
leaq 0x48(%rsp), %rdi
callq 0x21e0
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a2b(%rip), %rsi      # 0x4004
leaq 0x28(%rsp), %rdi
movq %rbx, %rdx
callq 0x2acf
leaq 0x1a37(%rip), %rdx      # 0x4024
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2ab0
leaq 0x28(%rsp), %rdi
callq 0x22a8
pushq $0x20
popq %rdi
callq 0x20c0
leaq 0x10(%rax), %rdx
movq %rdx, (%rax)
leaq 0x18(%rsp), %rcx
movq -0x10(%rcx), %rsi
cmpq %rcx, %rsi
jne 0x262b
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x2637
movq %rsi, (%rax)
movq 0x18(%rsp), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rsp), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x36f1(%rip), %rsi      # 0x5d48
movq 0x3962(%rip), %rdx      # 0x5fc0
movq %rax, %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2678
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x22a8
jmp 0x2686
jmp 0x2683
jmp 0x2683
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x21e0
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
incq (%rax)
callq 0x29fe
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
addq $0x10, %rbx
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x2a38
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x0, (%rdi)
je 0x2a36
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
decq (%rdi)
jne 0x2a2a
pushq $0x8
popq %rsi
callq 0x2130
leaq 0x10(%rbx), %rdi
movq (%rbx), %rsi
callq 0x2a98
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hcoona[P]POJ-Solutions/P1018.cpp
// Function: POJ::P1018::Run(std::istream&, std::ostream&)
void P1018::Run(istream &in, ostream &out)
    {
        const int NMax = 100;
        const int MMax = 100;
        vector<vector<pair<int, int> > > deviceData(NMax, vector<pair<int, int> >(MMax));

        int t;
        in >> t;
        while (t--) {
            int n;
            in >> n;

            for (int nidx = 0; nidx < n; nidx++) {
                int m;
                in >> m;
                for (int midx = 0; midx < m; midx++) {
                    int b, p;
                    in >> b >> p;
                    deviceData[nidx][midx] = make_pair(b, p);
                }
                sort(
                    deviceData[nidx].begin(),
                    deviceData[nidx].end(),
                    PredByFirstGt<int, int>);
            }

            out << setprecision(3) << fixed << Solve(deviceData) << endl;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
leaq 0x18(%rsp), %rdi
pushq $0x64
popq %rsi
leaq 0x4(%rsp), %rdx
callq 0x15a2
leaq 0x30(%rsp), %rdi
pushq $0x64
popq %rsi
leaq 0x18(%rsp), %rdx
movq %rsp, %rcx
callq 0x15f4
leaq 0x18(%rsp), %rdi
callq 0x1754
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x1090
leaq 0xc(%rsp), %r13
leaq 0x8(%rsp), %rbp
subl $0x1, 0x18(%rsp)
jb 0x13b9
movq %r14, %rdi
leaq 0x4(%rsp), %rsi
callq 0x1090
xorl %ebx, %ebx
movslq 0x4(%rsp), %rax
cmpq %rax, %rbx
jge 0x136d
movq %r14, %rdi
movq %rsp, %rsi
callq 0x1090
imulq $0x18, %rbx, %r12
xorl %r15d, %r15d
movslq (%rsp), %rax
cmpq %rax, %r15
jge 0x134e
movq %r14, %rdi
movq %r13, %rsi
callq 0x1090
movq %rax, %rdi
movq %rbp, %rsi
callq 0x1090
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
movq 0x30(%rsp), %rdx
movq (%rdx,%r12), %rdx
movl %eax, (%rdx,%r15,8)
movl %ecx, 0x4(%rdx,%r15,8)
incq %r15
jmp 0x1310
movq 0x30(%rsp), %rax
movq (%rax,%r12), %rdi
movq 0x8(%rax,%r12), %rsi
leaq 0x9e(%rip), %rdx        # 0x1401
callq 0x19bd
incq %rbx
jmp 0x12f4
movq 0x10(%rsp), %rdx
movq (%rdx), %rax
movq -0x18(%rax), %rcx
movq $0x3, 0x8(%rdx,%rcx)
movq -0x18(%rax), %rax
movl 0x18(%rdx,%rax), %ecx
movl $0xfffffefb, %esi       # imm = 0xFFFFFEFB
andl %esi, %ecx
orl $0x4, %ecx
movl %ecx, 0x18(%rdx,%rax)
leaq 0x30(%rsp), %rsi
callq 0x140a
movq 0x10(%rsp), %rdi
callq 0x1120
movq %rax, %rdi
callq 0x1070
jmp 0x12da
leaq 0x30(%rsp), %rdi
callq 0x164a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13ec
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1754
jmp 0x13f9
movq %rax, %rbx
jmp 0x13f9
jmp 0x13ec
jmp 0x13ec
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x164a
movq %rbx, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/include/policies.hpp
// Function: BackupSmartFilled<boost::intrusive::list<Intrusive<8u, (boost::intrusive::link_mode_type)1>, 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x2a31a(%rip), %rcx     # 0x311b8
movq 0x2a30b(%rip), %r15     # 0x311b0
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, %rax
subq %r15, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
cmpq %r14, %rax
je 0x6f0c
cmpq %r15, %rcx
je 0x6eca
movq %r15, 0x2a2ee(%rip)     # 0x311b8
leaq 0x2a2df(%rip), %r15     # 0x311b0
movq %r14, %rsi
movq %r15, %rdi
callq 0x6f9a
xorl %r13d, %r13d
movq %rsp, %r12
cmpq %r13, %r14
je 0x6f05
vxorps %xmm0, %xmm0, %xmm0
movq %r15, %rdi
movq %r12, %rsi
vmovaps %xmm0, (%rsp)
movq %r13, 0x10(%rsp)
callq 0x70ec
incq %r13
jmp 0x6ee2
movq 0x2a2a4(%rip), %r15     # 0x311b0
pushq $0x10
popq %rdi
callq 0x2190
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %rax, (%rbx)
xorl %ecx, %ecx
movq %r15, %rdx
movq %rax, %rsi
subq $0x1, %r14
jb 0x6f4a
movq %rsi, 0x8(%rdx)
movq %rax, (%rdx)
movq %rdx, 0x8(%rax)
movq %rdx, (%rsi)
imulq $0x18, %rcx, %rsi
incq %rcx
addq $0x18, %rdx
addq %r15, %rsi
jmp 0x6f26
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/include/policies.hpp
// Function: EmptyPrepareBackup<std::__cxx11::list<Normal<8u>, std::allocator<Normal<8u>>>>::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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x1c93e(%rip), %rcx     # 0x31518
movq 0x1c92f(%rip), %rax     # 0x31510
movq %rdi, %rbx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jne 0x14c10
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %r14
cmpq %rax, %rcx
je 0x14c1f
movq %rax, 0x1c8f9(%rip)     # 0x31518
leaq 0x1c8ea(%rip), %r15     # 0x31510
movq %r14, %rsi
movq %r15, %rdi
callq 0xc518
leaq 0x8(%rsp), %r12
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x14bf3
movq %r13, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xc71c
incq %r13
jmp 0x14c39
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %r14d
movl %edi, %r15d
leaq 0x40(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
xorl %ebx, %ebx
leaq 0xc(%rsp), %r12
leaq 0x8(%rsp), %r13
movl %edi, %ebp
subl $0x1, %ebp
jb 0x1572
movl %r14d, %edi
callq 0x127c
movl %eax, %r14d
movl %r15d, %edi
movl %eax, %esi
callq 0x12a7
movl %eax, 0xc(%rsp)
andl $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x165a
movl 0xc(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0xc(%rax)
addl %ecx, %ebx
incl %ebx
jmp 0x1530
movq 0x2a67(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0x10(%rsp), %r14
movq 0x18(%r14), %rdx
leaq 0xae9(%rip), %rsi       # 0x2075
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10f0
movl 0x18(%r14), %ebx
movq %r14, %rdi
callq 0x15c8
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x15c8
movq %rbx, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r12d, %r12d
movq 0x2de9(%rip), %rbx      # 0x3fe0
leaq -0x29(%rbp), %r14
leaq 0xe02(%rip), %r13       # 0x2004
xorl %r15d, %r15d
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1264
movsbl -0x29(%rbp), %eax
addl $-0x61, %eax
rorl %eax
cmpl $0xa, %eax
ja 0x121a
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
incl %r12d
jmp 0x121a
incl -0x38(%rbp)
jmp 0x121a
incl -0x30(%rbp)
jmp 0x121a
incl -0x34(%rbp)
jmp 0x121a
incl %r15d
jmp 0x121a
movq 0x2d65(%rip), %rdi      # 0x3fd0
leaq 0xdbe(%rip), %rsi       # 0x2030
callq 0x1060
movl %r12d, %esi
movq %rax, %rdi
callq 0x1040
pushq $0xa
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x1070
leaq 0xdaf(%rip), %rsi       # 0x2045
movq %rax, %rdi
callq 0x1060
movl %r15d, %esi
movq %rax, %rdi
callq 0x1040
movq %rax, %rdi
movl %ebx, %esi
callq 0x1070
leaq 0xda0(%rip), %rsi       # 0x205a
movq %rax, %rdi
callq 0x1060
movl -0x30(%rbp), %esi
movq %rax, %rdi
callq 0x1040
movq %rax, %rdi
movl %ebx, %esi
callq 0x1070
leaq 0xd91(%rip), %rsi       # 0x206f
movq %rax, %rdi
callq 0x1060
movl -0x34(%rbp), %esi
movq %rax, %rdi
callq 0x1040
movq %rax, %rdi
movl %ebx, %esi
callq 0x1070
leaq 0xd82(%rip), %rsi       # 0x2084
movq %rax, %rdi
callq 0x1060
movl -0x38(%rbp), %esi
movq %rax, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f3f(%rip), %rax      # 0x9228
movl %edi, (%rax)
leaq 0x5f3a(%rip), %rax      # 0x922c
movl %esi, (%rax)
imull %edi, %esi
movslq %esi, %rax
leaq (,%rax,4), %rdi
testl %eax, %eax
pushq $-0x1
popq %rcx
cmovsq %rcx, %rdi
leaq (,%rax,8), %rbx
cmovsq %rcx, %rbx
callq 0x1030
leaq 0x5ef5(%rip), %rcx      # 0x9218
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x1030
leaq 0x5eeb(%rip), %rcx      # 0x9220
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3343
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e12(%rip), %rax      # 0x9160
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_O2/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 0x5e51(%rip), %rax      # 0x91e0
movsd %xmm0, (%rax)
leaq 0x5e4e(%rip), %rax      # 0x91e8
movsd %xmm1, (%rax)
leaq 0x5e4b(%rip), %rax      # 0x91f0
movsd %xmm2, (%rax)
leaq 0x5e48(%rip), %rax      # 0x91f8
movsd %xmm3, (%rax)
leaq 0x5e45(%rip), %rax      # 0x9200
movsd %xmm4, (%rax)
leaq 0x5e42(%rip), %rax      # 0x9208
movsd %xmm5, (%rax)
popq %rbp
retq