LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tyhsu[P]Ewn/minimax.cpp
// Function: Minimax::simulation(Game)
int Minimax::simulation(Game simu_game) {
	char cur_symbol;
	int game_status = 0, ai_win = this->ai_side ? 2 : 1;
	if (simu_game.get_is_switch() == this->ai_side)
		cur_symbol = this->ai_symbol;
	else
		cur_symbol = this->ai_side? '1' : 'A';

	while (game_status == 0) {
		Movement available_mvmt_list[18];
		int available_mvmt_cnt = 0;

		// find all avaible move (6 dice indices, 3 directions)
		for(int chs_index = 0; chs_index < 6; chs_index++) {
			Chess cur_chs = simu_game.get_cur_chs_list(chs_index);
			if (cur_chs.exist) {
				for (int direct = 0; direct < 3; direct++) {
					Movement tmp_mvmt(chs_index, direct);
					if (simu_game.check_in_board(tmp_mvmt)) {
						available_mvmt_list[available_mvmt_cnt] = tmp_mvmt;
						available_mvmt_cnt ++;
					}
				}
			}
		}
		// randomly pick a move.
		Movement next_mvmt = available_mvmt_list[rand() % available_mvmt_cnt];
		game_status = simu_game.update_game_status(next_mvmt);

		// check game status => if the game keep going, switch the player.
		if(game_status == 0) simu_game.switch_player();
		else break;
	}
	// return the result of game.
	return (game_status == ai_win? 1 : 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movb 0x10(%rdi), %al
movb %al, -0x29(%rbp)
movq %rsi, %rdi
callq 0x872e
leaq -0x30(%rbp), %r15
leaq -0x38(%rbp), %r12
xorl %r13d, %r13d
movl $0x90, %edx
leaq -0xd0(%rbp), %rdi
xorl %esi, %esi
callq 0x2090
movl $0x0, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x86e0
btl $0x8, %eax
jae 0x7416
xorl %r14d, %r14d
movl -0x30(%rbp), %eax
movl %eax, -0x38(%rbp)
movl %r14d, -0x34(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8118
testb %al, %al
je 0x740d
movslq %r13d, %r13
movq -0x38(%rbp), %rax
movq %rax, -0xd0(%rbp,%r13,8)
incl %r13d
incl %r14d
cmpl $0x3, %r14d
jne 0x73e2
movl -0x30(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x30(%rbp)
cmpl $0x5, %eax
jl 0x73ce
callq 0x2060
cltd
idivl %r13d
movslq %edx, %rax
movq -0xd0(%rbp,%rax,8), %rax
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x818e
testl %eax, %eax
jne 0x7458
movq %rbx, %rdi
callq 0x8316
jmp 0x73b1
movzbl -0x29(%rbp), %edx
incl %edx
xorl %ecx, %ecx
cmpl %edx, %eax
sete %cl
movl %ecx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tyhsu[P]Ewn/game.cpp
// Function: Chess::assign(char const&, bool const&, int const&, int const&)
void Chess::assign(const char& symbol_, const bool& exist_, const int& x, const int& y)
{
	this->symbol = symbol_;
	this->exist = exist_;
	this->x = x;
	this->y = y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rsi), %al
movb %al, (%rdi)
movb (%rdx), %al
movb %al, 0x1(%rdi)
movl (%rcx), %eax
movl %eax, 0x4(%rdi)
movl (%r8), %eax
movl %eax, 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tyhsu[P]Ewn/game.cpp
// Function: Game::Game(Game const&)
Game::Game(const Game& game)
{
	for(int i=0; i<5; i++) {
		for(int j=0; j<5; j++) {
			this->board[i][j] = game.board[i][j];
		}
	}
	for(int i=0; i<2; i++) {
		this->movable_chs_list[i] = game.movable_chs_list[i];
	}
	for(int i=0; i<6; i++) {
		this->chs_list_A[i] = game.chs_list_A[i];
		this->chs_list_B[i] = game.chs_list_B[i];
	}
	this->exist_bitwise_A = game.exist_bitwise_A;
	this->exist_bitwise_B = game.exist_bitwise_B;
	this->is_switch = game.is_switch;
	this->cur_chs_list_ptr = (this->is_switch == false) ? this->chs_list_A :  this->chs_list_B;
	this->cur_exist_bitwise_ptr = (this->is_switch == false) ? this->exist_bitwise_A :  this->exist_bitwise_B;
	this->exist_chs_num_A = game.exist_chs_num_A;
	this->exist_chs_num_B = game.exist_chs_num_B;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rdi, %rcx
movq %rsi, %rdx
xorl %r8d, %r8d
movb (%rdx,%r8), %r9b
movb %r9b, (%rcx,%r8)
incq %r8
cmpq $0x5, %r8
jne 0x7a83
incq %rax
addq $0x5, %rdx
addq $0x5, %rcx
cmpq $0x5, %rax
jne 0x7a80
leaq 0x1c(%rsi), %rax
leaq 0x1c(%rdi), %rcx
xorl %edx, %edx
movl 0x8(%rax,%rdx), %r8d
movl %r8d, 0x8(%rcx,%rdx)
movq (%rax,%rdx), %r8
movq %r8, (%rcx,%rdx)
addq $0xc, %rdx
cmpq $0xc, %rdx
je 0x7aaf
movl $0x84, %eax
leaq (%rsi,%rax), %rcx
addq %rdi, %rax
movq $-0x48, %rdx
movl 0x8(%rcx,%rdx), %r8d
movl %r8d, 0x8(%rax,%rdx)
movq (%rcx,%rdx), %r8
movq %r8, (%rax,%rdx)
movq 0x48(%rcx,%rdx), %r8
movq %r8, 0x48(%rax,%rdx)
movl 0x50(%rcx,%rdx), %r8d
movl %r8d, 0x50(%rax,%rdx)
addq $0xc, %rdx
jne 0x7ade
movl 0xd8(%rsi), %eax
leaq 0xd8(%rdi), %rcx
movl %eax, 0xd8(%rdi)
movl 0xdc(%rsi), %eax
leaq 0xdc(%rdi), %rdx
movl %eax, 0xdc(%rdi)
movb 0xe4(%rsi), %al
movb %al, 0xe4(%rdi)
leaq 0x84(%rdi), %r8
leaq 0x3c(%rdi), %r9
testb %al, %al
cmovneq %r8, %r9
movq %r9, 0xd0(%rdi)
cmoveq %rcx, %rdx
movl (%rdx), %eax
movl %eax, 0xe0(%rdi)
movl 0x34(%rsi), %eax
movl %eax, 0x34(%rdi)
movl 0x38(%rsi), %eax
movl %eax, 0x38(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tyhsu[P]Ewn/game.cpp
// Function: Game::operator=(Game const&)
void Game::operator=(const Game& game)
{
	for(int i=0; i<5; i++) {
		for(int j=0; j<5; j++) {
			this->board[i][j] = game.board[i][j];
		}
	}
	for(int i=0; i<2; i++) {
		this->movable_chs_list[i] = game.movable_chs_list[i];
	}
	for(int i=0; i<6; i++) {
		this->chs_list_A[i] = game.chs_list_A[i];
		this->chs_list_B[i] = game.chs_list_B[i];
	}
	this->exist_bitwise_A = game.exist_bitwise_A;
	this->exist_bitwise_B = game.exist_bitwise_B;
	this->is_switch = game.is_switch;
	this->cur_chs_list_ptr = (game.is_switch) ? this->chs_list_B : this->chs_list_A;
	this->exist_chs_num_A = game.exist_chs_num_A;
	this->exist_chs_num_B = game.exist_chs_num_B;
//	cout << "calling copy : "  << this->is_switch << " " << this->cur_chs_list_ptr << "  " << this->chs_list_A << "  " << this->chs_list_B << "  " << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rdi, %rcx
movq %rsi, %rdx
xorl %r8d, %r8d
movb (%rdx,%r8), %r9b
movb %r9b, (%rcx,%r8)
incq %r8
cmpq $0x5, %r8
jne 0x7b7d
incq %rax
addq $0x5, %rdx
addq $0x5, %rcx
cmpq $0x5, %rax
jne 0x7b7a
leaq 0x1c(%rsi), %rax
leaq 0x1c(%rdi), %rcx
xorl %edx, %edx
movl 0x8(%rax,%rdx), %r8d
movl %r8d, 0x8(%rcx,%rdx)
movq (%rax,%rdx), %r8
movq %r8, (%rcx,%rdx)
addq $0xc, %rdx
cmpq $0xc, %rdx
je 0x7ba9
movl $0x84, %eax
leaq (%rsi,%rax), %rcx
addq %rdi, %rax
movq $-0x48, %rdx
movl 0x8(%rcx,%rdx), %r8d
movl %r8d, 0x8(%rax,%rdx)
movq (%rcx,%rdx), %r8
movq %r8, (%rax,%rdx)
movq 0x48(%rcx,%rdx), %r8
movq %r8, 0x48(%rax,%rdx)
movl 0x50(%rcx,%rdx), %r8d
movl %r8d, 0x50(%rax,%rdx)
addq $0xc, %rdx
jne 0x7bd8
movl 0xd8(%rsi), %eax
movl %eax, 0xd8(%rdi)
movl 0xdc(%rsi), %eax
movl %eax, 0xdc(%rdi)
movb 0xe4(%rsi), %al
movb %al, 0xe4(%rdi)
leaq 0x3c(%rdi), %rax
cmpb $0x0, 0xe4(%rsi)
leaq 0x84(%rdi), %rcx
cmovneq %rcx, %rax
movq %rax, 0xd0(%rdi)
movl 0x34(%rsi), %eax
movl %eax, 0x34(%rdi)
movl 0x38(%rsi), %eax
movl %eax, 0x38(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tyhsu[P]Ewn/game.cpp
// Function: Game::set_board(char (*) [5], int)
void Game::set_board(char board_[5][5], int is_switch_)
{
	int chs_num_A_ = 0, chs_num_B_ = 0;
	int exist_bitwise_A_ = 0, exist_bitwise_B_ = 0;
	for (int i=0; i<6; i++) {
		this->chs_list_A[i].assign(0, false, 0, 0);
		this->chs_list_B[i].assign(0, false, 4, 4);
	}

	for (int i=0; i<5; i++) {
		for (int j=0; j<5; j++) {
			char c = board_[j][i];

			//Set the board
			this->board[i][j] = c;

			//Update other information
			if (c>='1' && c<='6') {
				chs_num_A_++;
				this->chs_list_A[c-'1'].assign(c, true, i, j);
				exist_bitwise_A_ |= 1 << (c-'1');
			}
			else if (c>='A' && c<='f') {
				chs_num_B_++;
				this->chs_list_B[c-'A'].assign(c, true, i, j);
				exist_bitwise_B_ |= 1 << (c-'A');
			}
		}
	}
	this->exist_chs_num_A = chs_num_A_;
	this->exist_chs_num_B = chs_num_B_;
	this->exist_bitwise_A = exist_bitwise_A_;
	this->exist_bitwise_B = exist_bitwise_B_;

	if (is_switch_) {
		this->cur_chs_list_ptr = this->chs_list_B;
		this->cur_exist_bitwise_ptr = this->exist_bitwise_B;
		this->is_switch = true;
	}
	else {
		this->cur_chs_list_ptr = this->chs_list_A;
		this->cur_exist_bitwise_ptr = this->exist_bitwise_A;
		this->is_switch = false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, -0x2c(%rbp)
movq $-0x48, %rax
xorl %ecx, %ecx
movabsq $0x400000004, %rdx      # imm = 0x400000004
movw %cx, 0x84(%rdi,%rax)
movq $0x0, 0x88(%rdi,%rax)
movw %cx, 0xcc(%rdi,%rax)
movq %rdx, 0xd0(%rdi,%rax)
addq $0xc, %rax
jne 0x7c77
leaq 0x84(%rdi), %rax
leaq 0x3c(%rdi), %rcx
xorl %r10d, %r10d
movq %rdi, -0x38(%rbp)
movq %rdi, %r11
xorl %edi, %edi
xorl %r8d, %r8d
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rsi, %r15
xorl %r12d, %r12d
movb (%r15), %r9b
movb %r9b, (%r11,%r12)
movsbl %r9b, %r13d
leal -0x31(%r13), %edx
cmpb $0x5, %dl
ja 0x7d05
incl %r14d
addl $-0x31, %r13d
leaq (,%r13,2), %rdx
addq %r13, %rdx
movb %r9b, (%rcx,%rdx,4)
movb $0x1, 0x1(%rcx,%rdx,4)
movl %r10d, 0x4(%rcx,%rdx,4)
movl %r12d, 0x8(%rcx,%rdx,4)
btsl %r13d, %r8d
jmp 0x7d36
leal -0x41(%r9), %edx
cmpb $0x25, %dl
ja 0x7d36
incl %ebx
addl $-0x41, %r13d
leaq (,%r13,2), %rdx
addq %r13, %rdx
movb %r9b, (%rax,%rdx,4)
movb $0x1, 0x1(%rax,%rdx,4)
movl %r10d, 0x4(%rax,%rdx,4)
movl %r12d, 0x8(%rax,%rdx,4)
btsl %r13d, %edi
incq %r12
addq $0x5, %r15
cmpq $0x5, %r12
jne 0x7cc6
incq %r10
addq $0x5, %r11
incq %rsi
cmpq $0x5, %r10
jne 0x7cc0
movq -0x38(%rbp), %rdx
movl %r14d, 0x34(%rdx)
movl %ebx, 0x38(%rdx)
movl %r8d, 0xd8(%rdx)
cmpl $0x0, -0x2c(%rbp)
cmovnel %edi, %r8d
movl %edi, 0xdc(%rdx)
cmovneq %rax, %rcx
movq %rcx, 0xd0(%rdx)
movl %r8d, 0xe0(%rdx)
setne 0xe4(%rdx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tyhsu[P]Ewn/game.cpp
// Function: Game::count_movable_chs(int const&)
int Game::count_movable_chs(const int& dice)
{
	for(int i = 0; i < 2; i++)
		this->movable_chs_list[i].assign(0, false, 0, 0);

	if (this->cur_chs_list_ptr[dice].exist == true) {
		// this piece is alive!
		for(int i = 0; i < 2; i++)
			this->movable_chs_list[i] = this->cur_chs_list_ptr[dice];
		return 1;
	}
	else {
		int movable_chs_cnt = 2;

		// search for maybe other two.
		for (int i = dice-1; i >= 0; i--) {
			if (this->cur_chs_list_ptr[i].exist){
				this->movable_chs_list[0] = this->cur_chs_list_ptr[i];
				break;
			}
		}
		for (int i = dice+1; i < 6; i++) {
			if (this->cur_chs_list_ptr[i].exist){
				this->movable_chs_list[1] = this->cur_chs_list_ptr[i];
				break;
			}
		}

		// if one of movable_chs_list doesn't value, let this Chs = the other one (with value).
		for (int i = 0; i < 2; i++) {
			if (this->movable_chs_list[i].symbol == 0) {
				this->movable_chs_list[i] = this->movable_chs_list[1-i];
				movable_chs_cnt--;
			}
		}
		return movable_chs_cnt;
	}
}

// Assembly:
xorl %eax, %eax
movw $0x0, 0x1c(%rdi,%rax)
movq $0x0, 0x20(%rdi,%rax)
addq $0xc, %rax
cmpq $0xc, %rax
je 0x800e
pushq %rbp
movq %rsp, %rbp
movq 0xd0(%rdi), %rax
movslq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rdx
cmpb $0x0, 0x1(%rax,%rdx,4)
je 0x807b
leaq 0x1c(%rdi), %rax
xorl %ecx, %ecx
movq 0xd0(%rdi), %rdx
movslq (%rsi), %r8
leaq (%r8,%r8,2), %r8
movl 0x8(%rdx,%r8,4), %r9d
movl %r9d, 0x8(%rax,%rcx)
movq (%rdx,%r8,4), %rdx
movq %rdx, (%rax,%rcx)
addq $0xc, %rcx
cmpq $0xc, %rcx
je 0x8047
movl $0x1, %eax
jmp 0x8115
movl %ecx, %ecx
leaq (%rcx,%rcx,2), %rdx
leaq (%rax,%rdx,4), %rdx
incl %ecx
decl %ecx
testl %ecx, %ecx
jle 0x80a8
leaq -0xc(%rdx), %r8
cmpb $0x1, -0xb(%rdx)
movq %r8, %rdx
jne 0x8087
movl 0x8(%r8), %ecx
movl %ecx, 0x24(%rdi)
movq (%r8), %rcx
movq %rcx, 0x1c(%rdi)
movslq (%rsi), %rdx
cmpl $0x6, %edx
movl $0x5, %ecx
cmovgel %edx, %ecx
subq %rdx, %rcx
incq %rcx
leaq (%rdx,%rdx,2), %rdx
leaq (%rax,%rdx,4), %rax
decq %rcx
je 0x80e3
leaq 0xc(%rax), %rdx
cmpb $0x1, 0xd(%rax)
movq %rdx, %rax
jne 0x80c4
movl 0x8(%rdx), %eax
movl %eax, 0x30(%rdi)
movq (%rdx), %rax
movq %rax, 0x28(%rdi)
leaq 0x1c(%rdi), %rcx
addq $0x28, %rdi
movl $0x2, %eax
xorl %edx, %edx
cmpb $0x0, (%rcx)
jne 0x8107
movl 0x8(%rdi,%rdx), %esi
movl %esi, 0x8(%rcx)
movq (%rdi,%rdx), %rsi
movq %rsi, (%rcx)
decl %eax
addq $-0xc, %rdx
addq $0xc, %rcx
cmpq $-0xc, %rdx
je 0x80f2
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tyhsu[P]Ewn/game.cpp
// Function: Game::check_in_board(std::pair<int, int> const&)
bool Game::check_in_board(const Movement& mvmt)
{
	Chess chs = this->cur_chs_list_ptr[mvmt.first];
	int side = (this->is_switch == false) ? 1 : -1;
	int x = chs.x, y = chs.y;
	x += (mvmt.second == 1) ? 0 : side;
	y += (mvmt.second == 0) ? 0 : side;
	return ( x >= 0 && x < 5 && y >= 0 && y < 5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xd0(%rdi), %rax
movslq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
movzbl 0xe4(%rdi), %edx
negl %edx
orl $0x1, %edx
movl 0x4(%rsi), %esi
xorl %edi, %edi
cmpl $0x1, %esi
cmovnel %edx, %edi
addl 0x4(%rax,%rcx,4), %edi
testl %esi, %esi
cmovel %esi, %edx
addl 0x8(%rax,%rcx,4), %edx
cmpl $0x5, %edi
setb %cl
cmpl $0x5, %edx
setb %al
andb %cl, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tyhsu[P]Ewn/game.cpp
// Function: Game::switch_player()
void Game::switch_player()
{
	if (this->is_switch) {	//now is B
		this->cur_chs_list_ptr = this->chs_list_A;
		this->cur_exist_bitwise_ptr = this->exist_bitwise_A;
		this->is_switch = false;
	}
	else {				//now is A
		this->cur_chs_list_ptr = this->chs_list_B;
		this->cur_exist_bitwise_ptr = this->exist_bitwise_B;
		this->is_switch = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0xe4(%rdi)
jne 0x8339
leaq 0x3c(%rdi), %rax
movq %rax, 0xd0(%rdi)
leaq 0xd8(%rdi), %rcx
xorl %eax, %eax
jmp 0x8350
leaq 0x84(%rdi), %rax
movq %rax, 0xd0(%rdi)
leaq 0xdc(%rdi), %rcx
movb $0x1, %al
movl (%rcx), %ecx
movl %ecx, 0xe0(%rdi)
movb %al, 0xe4(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tyhsu[P]Ewn/game.cpp
// Function: Game::create_movable_chs_map()
Movable_chs_map Game::create_movable_chs_map()
{
	Movable_chs_map movable_chs_map_;
	for(int exist_=0; exist_<(1<<6); exist_++) { // each exist status
		for(int dice=0; dice<6; dice++) {
			int former_chs_index = -1, latter_chs_index = -1;
			for(int i=dice-1; i>=0; i--) {
				if((exist_%(1<<(i+1)))/(1<<i) == true) {
					former_chs_index = i;
					break;
				}
			}
			for(int i=dice+1; i<6; i++) {
				if((exist_>>i)%2 == true) {
					latter_chs_index = i;
					break;
				}
			}
			former_chs_index = (former_chs_index == -1) ? latter_chs_index : former_chs_index;
			latter_chs_index = (latter_chs_index == -1) ? former_chs_index : latter_chs_index;
			pair<int, int> fir(dice, exist_), sec(former_chs_index, latter_chs_index);
			movable_chs_map_.insert(make_pair(fir, sec));
		}
	}
	return movable_chs_map_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %r14d, %r14d
movq %r14, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %r14, 0x28(%rdi)
leaq -0x38(%rbp), %r15
movq %r14, %r12
shlq $0x20, %r12
xorl %r13d, %r13d
movl %r13d, %ecx
testl %ecx, %ecx
jle 0x879e
leal -0x1(%rcx), %esi
movl $0x1, %edi
shll %cl, %edi
movl %r14d, %eax
cltd
idivl %edi
movl %esi, %ecx
shrl %cl, %edx
movl %esi, %ecx
cmpl $0x1, %edx
jne 0x877d
jmp 0x87a3
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %r13d, %ecx
cmpl $0x5, %ecx
je 0x87bc
movl %r14d, %edx
shrl %cl, %edx
leal 0x1(%rcx), %eax
movl %eax, %ecx
testb $0x2, %dl
je 0x87a6
jmp 0x87c1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %esi
movl %esi, %ecx
cmovel %eax, %ecx
cmpl $-0x1, %eax
cmovel %esi, %eax
movq %r12, %rdx
orq %r13, %rdx
shlq $0x20, %rax
orq %rax, %rcx
movq %rdx, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x882a
incq %r13
cmpq $0x6, %r13
jne 0x877a
incq %r14
cmpq $0x40, %r14
jne 0x8770
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2840
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/include/cpp_utils/aligned_allocator.hpp
// Function: cpp::aligned_allocator<float, 32ul>::allocate(unsigned long) const
T* allocate(const std::size_t n) const {
        // The return value of allocate(0) is unspecified.
        // Mallocator returns nullptr in order to avoid depending
        // on malloc(0)'s implementation-defined behavior
        // (the implementation can define malloc(0) to return nullptr,
        // in which case the bad_alloc check below would fire).
        // All allocators can return nullptr in this case.
        if (n == 0) {
            return nullptr;
        }

        // All allocators should contain an integer overflow check.
        // The Standardization Committee recommends that std::length_error
        // be thrown in the case of integer overflow.
        if (n > max_size()) {
            throw std::length_error("aligned_allocator<T>::allocate() - Integer overflow.");
        }

        void* pv = aligned_allocate(n);

        // Allocators should throw std::bad_alloc in the case of memory allocation failure.
        if (!pv) {
            throw std::bad_alloc();
        }

        return static_cast<T*>(pv);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1770d
movq %rsi, %rax
shrq $0x3e, %rax
jne 0x17717
movq %rsi, %rdi
callq 0x1775c
testq %rax, %rax
jne 0x1770f
movl $0x8, %edi
callq 0x8200
movq 0x6b870(%rip), %rcx     # 0x82f60
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x6b8a2(%rip), %rsi     # 0x82fa0
movq 0x6b82b(%rip), %rdx     # 0x82f30
movq %rax, %rdi
callq 0x8780
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x8200
movq %rax, %rbx
leaq 0x48019(%rip), %rsi     # 0x5f744
movq %rax, %rdi
callq 0x8580
movq 0x6b876(%rip), %rsi     # 0x82fb0
movq 0x6b827(%rip), %rdx     # 0x82f68
movq %rbx, %rdi
callq 0x8780
movq %rax, %r14
movq %rbx, %rdi
callq 0x8350
movq %r14, %rdi
callq 0x87c0
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/include/cpp_utils/aligned_allocator.hpp
// Function: cpp::aligned_allocator<double, 48ul>::aligned_allocate(unsigned long)
static T* aligned_allocate(std::size_t size) {
        auto required_bytes = sizeof(T) * size;
        auto offset         = (A - 1) + sizeof(uintptr_t);
        auto orig           = malloc(required_bytes + offset);

        if (!orig) {
            return nullptr;
        }

        if ((reinterpret_cast<size_t>(orig) + sizeof(uintptr_t)) % A == 0) {
            auto aligned = reinterpret_cast<void**>((reinterpret_cast<size_t>(orig) + sizeof(uintptr_t)));
            aligned[-1] = orig;
            return reinterpret_cast<T*>(aligned);
        } else {
            auto diff    = (reinterpret_cast<size_t>(orig) + sizeof(uintptr_t)) % A;
            auto offset  = A - diff;
            auto aligned = reinterpret_cast<void**>((reinterpret_cast<size_t>(orig) + sizeof(uintptr_t) + offset));
            aligned[-1] = orig;
            return reinterpret_cast<T*>(aligned);
        }
    }

// Assembly:
pushq %rax
leaq 0x37(,%rdi,8), %rdi
callq 0x8620
testq %rax, %rax
je 0x17883
leaq 0x8(%rax), %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulxq %rcx, %rcx, %rcx
shrq $0x5, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rcx
negq %rcx
leaq 0x8(%rax,%rcx), %rsi
movq %rax, %rcx
subq %rsi, %rcx
addq $0x38, %rcx
testq %rsi, %rsi
cmoveq %rdx, %rcx
movq %rax, -0x8(%rcx)
jmp 0x17885
xorl %ecx, %ecx
movq %rcx, %rax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/include/cpp_utils/assert.hpp
// Function: void cpp::assertion::detail::assertion_failed_msg<char>(char const*, char const*, char const*, char const*, unsigned long)
void assertion_failed_msg(const CharT* expr, const char* msg, const char* function, const char* file, size_t line) {
    std::cerr
        << "***** Internal Program Error - assertion (" << expr << ") failed in "
        << function << ":\n"
        << file << '(' << line << "): " << msg << std::endl;
    std::abort();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movq 0x6a8ff(%rip), %rbp     # 0x82fe8
leaq 0x4729b(%rip), %rsi     # 0x5f98b
movl $0x2a, %edx
movq %rbp, %rdi
callq 0x8560
testq %r13, %r13
jne 0x1871d
movq (%rbp), %rax
movq -0x18(%rax), %rax
leaq (%rbp,%rax), %rdi
movl 0x20(%rbp,%rax), %esi
orl $0x1, %esi
callq 0x8760
jmp 0x18737
movq %r13, %rdi
callq 0x81b0
movq 0x6a8bc(%rip), %rdi     # 0x82fe8
movq %r13, %rsi
movq %rax, %rdx
callq 0x8560
movq 0x6a8aa(%rip), %r13     # 0x82fe8
leaq 0x47271(%rip), %rsi     # 0x5f9b6
movl $0xc, %edx
movq %r13, %rdi
callq 0x8560
testq %r12, %r12
jne 0x18773
movq (%r13), %rax
movq -0x18(%rax), %rax
leaq (%r13,%rax), %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x8760
jmp 0x1878d
movq %r12, %rdi
callq 0x81b0
movq 0x6a866(%rip), %rdi     # 0x82fe8
movq %r12, %rsi
movq %rax, %rdx
callq 0x8560
movq 0x6a854(%rip), %r12     # 0x82fe8
leaq 0x4eb8b(%rip), %rsi     # 0x67326
movl $0x2, %edx
movq %r12, %rdi
callq 0x8560
testq %r15, %r15
jne 0x187c8
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x8760
jmp 0x187e2
movq %r15, %rdi
callq 0x81b0
movq 0x6a811(%rip), %rdi     # 0x82fe8
movq %r15, %rsi
movq %rax, %rdx
callq 0x8560
leaq 0x7(%rsp), %rsi
movb $0x28, (%rsi)
movq 0x6a7f7(%rip), %rdi     # 0x82fe8
movl $0x1, %edx
callq 0x8560
movq %rax, %rdi
movq %r14, %rsi
callq 0x8300
movq %rax, %r14
leaq 0x471b3(%rip), %rsi     # 0x5f9c3
movl $0x3, %edx
movq %rax, %rdi
callq 0x8560
testq %rbx, %rbx
jne 0x1883e
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x8760
jmp 0x18854
movq %rbx, %rdi
callq 0x81b0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x8560
movq %r14, %rdi
callq 0x81f0
movl $0x4, %edi
callq 0x8200
movl $0x1, (%rax)
movq 0x6a6a5(%rip), %rsi     # 0x82f18
movq %rax, %rdi
xorl %edx, %edx
callq 0x8780
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/include/cpp_utils/data.hpp
// Function: void cpp::normalize<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>&)
void normalize(Container& container) {
    //normalize to zero-mean
    auto m = cpp::mean(container);
    for (auto& v : container) {
        v -= m;
    }

    //normalize to unit variance
    if (auto s = cpp::stddev(container, 0.0); s != 0.0) {
        for (auto& v : container) {
            v /= s;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
vxorpd %xmm1, %xmm1, %xmm1
cmpq %rcx, %rax
je 0x1b7fb
movq %rax, %rdx
vaddsd (%rdx), %xmm1, %xmm1
addq $0x8, %rdx
cmpq %rcx, %rdx
jne 0x1b7ee
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
movq %rcx, %rdx
subq %rax, %rdx
movabsq $0x3ffffffffffffff8, %r14 # imm = 0x3FFFFFFFFFFFFFF8
vcvtsi2sd %rsi, %xmm0, %xmm0
je 0x1b87e
vdivsd %xmm0, %xmm1, %xmm2
addq $-0x8, %rdx
vpbroadcastq %rdx, %zmm1
shrq $0x3, %rdx
addq $0x8, %rdx
andq %r14, %rdx
vpsrlq $0x3, %zmm1, %zmm1
vbroadcastsd %xmm2, %zmm2
xorl %esi, %esi
vpmovsxbq 0x441fa(%rip), %zmm3 # 0x5fa48
vpbroadcastq %rsi, %zmm4
vporq %zmm3, %zmm4, %zmm4
vpcmpleuq %zmm1, %zmm4, %k1
vmovupd (%rax,%rsi,8), %zmm4 {%k1} {z}
vsubpd %zmm2, %zmm4, %zmm4
vmovupd %zmm4, (%rax,%rsi,8) {%k1}
addq $0x8, %rsi
cmpq %rsi, %rdx
jne 0x1b84e
vxorpd %xmm1, %xmm1, %xmm1
vxorpd %xmm2, %xmm2, %xmm2
cmpq %rcx, %rax
je 0x1b89a
vmovsd (%rax), %xmm3
vfmadd231sd %xmm3, %xmm3, %xmm2 # xmm2 = (xmm3 * xmm3) + xmm2
addq $0x8, %rax
jmp 0x1b886
vdivsd %xmm0, %xmm2, %xmm0
vucomisd %xmm1, %xmm0
jb 0x1b8aa
vsqrtsd %xmm0, %xmm0, %xmm0
jmp 0x1b8b2
vzeroupper
callq 0x83c0
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jne 0x1b8be
jnp 0x1b92b
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x1b92b
subq %rax, %rcx
addq $-0x8, %rcx
vpbroadcastq %rcx, %zmm1
shrq $0x3, %rcx
addq $0x8, %rcx
andq %r14, %rcx
vpsrlq $0x3, %zmm1, %zmm1
vbroadcastsd %xmm0, %zmm0
xorl %edx, %edx
vpmovsxbq 0x4414d(%rip), %zmm2 # 0x5fa48
vpbroadcastq %rdx, %zmm3
vporq %zmm2, %zmm3, %zmm3
vpcmpleuq %zmm1, %zmm3, %k1
vmovupd (%rax,%rdx,8), %zmm3 {%k1} {z}
vdivpd %zmm0, %zmm3, %zmm3
vmovupd %zmm3, (%rax,%rdx,8) {%k1}
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0x1b8fb
addq $0x8, %rsp
popq %rbx
popq %r14
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/doctest/doctest/doctest.h
// Function: doctest::detail::Expression_lhs<bool&>::operator doctest::detail::Result()
DOCTEST_NOINLINE operator Result() {
// this is needed only for MSVC 2015
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4800) // 'int': forcing value to bool
            bool res = static_cast<bool>(lhs);
DOCTEST_MSVC_SUPPRESS_WARNING_POP
            if(m_at & assertType::is_false) { //!OCLINT bitwise operator in conditional
                res = !res;
            }

            if(!res || getContextOptions()->success) {
                return { res, (DOCTEST_STRINGIFY(lhs)) };
            }
            return { res };
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movb (%rax), %bpl
xorb 0x9(%rsi), %bpl
testb $0x1, %bpl
je 0x1d9a3
callq 0x40ff6
cmpb $0x1, 0x6c(%rax)
jne 0x1d9ca
movq (%r14), %rax
movzbl (%rax), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x410fc
movzbl %bpl, %esi
andl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4206c
jmp 0x1d9e7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x40118
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x4206c
leaq 0x8(%rsp), %rdi
callq 0x40120
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1d9ff
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40120
movq %rbx, %rdi
callq 0x87c0
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/include/cpp_utils/thread_pool.hpp
// Function: void cpp::default_thread_pool<std::deque>::do_task<DOCTEST_ANON_FUNC_2()::$_0, int>(DOCTEST_ANON_FUNC_2()::$_0, int)
void do_task(Functor fun, Args... args) {
        with_lock(main_lock, [fun, args..., this] () mutable {
            if (stop_flag) {
#ifndef CPP_UTILS_NO_EXCEPT
                throw std::runtime_error("cpp_utils: enqueue on stopped ThreadPool");
#else
                std::cerr << "cpp_utils: enqueue on stopped ThreadPool (exceptions disabled)" << std::endl;
                std::abort();
#endif
            }

            //Execute the task
            tasks.emplace_back([fun, args...] () mutable {
                fun(args...);
            });
        });

        condition.notify_one();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x80(%rdi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x278ee
movb $0x1, 0x8(%r15)
movb 0x108(%rbx), %al
cmpb $0x1, %al
je 0x26434
movq 0x60(%rbx), %rax
movq 0x70(%rbx), %rcx
addq $-0x20, %rcx
cmpq %rcx, %rax
je 0x26343
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rax)
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
leaq 0x16d(%rip), %rcx       # 0x26494
movq %rcx, 0x18(%rax)
leaq 0x170(%rip), %rcx       # 0x264a2
movq %rcx, 0x10(%rax)
movq 0x60(%rbx), %rax
addq $0x20, %rax
jmp 0x26409
movq 0x50(%rbx), %rdx
movq 0x78(%rbx), %rcx
movq %rcx, %rsi
subq 0x58(%rbx), %rsi
shrq $0x3, %rsi
cmpq $0x1, %rcx
adcq $-0x1, %rsi
shlq $0x4, %rsi
subq 0x68(%rbx), %rax
sarq $0x5, %rax
subq 0x40(%rbx), %rdx
sarq $0x5, %rdx
addq %rax, %rdx
addq %rsi, %rdx
movabsq $0x7ffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFF
cmpq %rax, %rdx
je 0x26466
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rcx
sarq $0x3, %rcx
subq %rcx, %rax
cmpq $0x1, %rax
ja 0x263b0
leaq 0x30(%rbx), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x27ff2
movl $0x200, %edi            # imm = 0x200
callq 0x84e0
movq 0x78(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x60(%rbx), %rax
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rax)
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
leaq 0xb9(%rip), %rcx        # 0x26494
movq %rcx, 0x18(%rax)
leaq 0xbc(%rip), %rcx        # 0x264a2
movq %rcx, 0x10(%rax)
movq 0x78(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x78(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x68(%rbx)
leaq 0x200(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq %rax, 0x60(%rbx)
leaq 0x8(%rsp), %rdi
vzeroupper
callq 0x276ae
addq $0xa8, %rbx
movq %rbx, %rdi
callq 0x8210
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x8200
movq %rax, %rbx
leaq 0x3b1ba(%rip), %rsi     # 0x61602
movq %rax, %rdi
callq 0x8190
movq 0x5cb99(%rip), %rsi     # 0x82ff0
movq 0x5cb12(%rip), %rdx     # 0x82f70
movq %rbx, %rdi
callq 0x8780
leaq 0x3b1be(%rip), %rdi     # 0x6162b
callq 0x8250
movq %rax, %r14
movq %rbx, %rdi
callq 0x8350
jmp 0x26482
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x276ae
movq %r14, %rdi
callq 0x87c0
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/include/cpp_utils/thread_pool.hpp
// Function: cpp::default_thread_pool<std::deque>::~default_thread_pool()
~default_thread_pool() {
        with_lock(main_lock, [this] { stop_flag = true; });

        condition.notify_all();

        for (auto& thread : threads) {
            thread.join();
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x80(%rdi), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x278ee
movb $0x1, %al
leaq 0x8(%rsp), %rdi
movb %al, 0x8(%rdi)
movb %al, 0x108(%rbx)
callq 0x276ae
leaq 0xa8(%rbx), %r14
movq %r14, %rdi
callq 0x8770
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x27380
movq %r15, %rdi
callq 0x8890
addq $0x8, %r15
jmp 0x2736d
leaq 0xd8(%rbx), %rdi
callq 0x87e0
movq %r14, %rdi
callq 0x87e0
leaq 0x30(%rbx), %rdi
callq 0x276c4
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x273b2
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x8500
movq %rbx, %rdi
callq 0x27704
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x273c8
movq %rax, %rdi
callq 0x13dd8
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/include/cpp_utils/thread_pool.hpp
// Function: cpp::default_thread_pool<std::deque>::default_thread_pool(unsigned long)
explicit default_thread_pool(std::size_t n) : status(n, thread_status::WAITING) {
        // The thread pool is of fixed size, avoid any possible reallocation
        threads.reserve(n);

        // Lets all the threads start at the same time and avoid any possible race conditions
        std::unique_lock<std::mutex> ulock(main_lock);

        for (std::size_t t = 0; t < n; ++t) {
            threads.emplace_back([this, t] {
                while (true) {
                    std::function<void()> task;

                    {
                        std::unique_lock<std::mutex> ulock(main_lock);

                        status[t] = thread_status::WAITING;

                        wait_condition.notify_one();

                        condition.wait(ulock, [this] {
                            return stop_flag || !tasks.empty();
                        });

                        if (stop_flag && tasks.empty()) {
                            return;
                        }

                        task = std::move(tasks.front());
                        tasks.pop_front();

                        status[t] = thread_status::WORKING;
                    }

                    task();
                }
            });
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r12
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x8(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
callq 0x2754c
leaq 0x30(%rbx), %r15
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x40(%rbx)
vmovups %zmm0, 0x30(%rbx)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, 0x20(%rsp)
vzeroupper
callq 0x2775c
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x80(%rbx)
movq $0x0, 0xa0(%rbx)
leaq 0xa8(%rbx), %r13
movq %r13, %rdi
vzeroupper
callq 0x8670
leaq 0xd8(%rbx), %rbp
movq %rbp, %rdi
callq 0x8670
movb $0x0, 0x108(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, 0x18(%rsp)
callq 0x275cc
leaq 0x80(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x278ee
movb $0x1, 0x10(%rsp)
testq %r12, %r12
je 0x274d1
xorl %r15d, %r15d
leaq 0x28(%rsp), %r14
movq %rbx, 0x28(%rsp)
movq %r15, 0x30(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27678
incq %r15
cmpq %r15, %r12
jne 0x274b4
leaq 0x8(%rsp), %rdi
callq 0x276ae
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x274ec
movq %rax, %r12
jmp 0x27508
movq %rax, %r12
jmp 0x27522
movq %rax, %r12
jmp 0x2753b
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x276ae
movq %rbp, %rdi
callq 0x87e0
movq %r13, %rdi
callq 0x87e0
movq 0x18(%rsp), %rdi
callq 0x276c4
movq 0x20(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2753b
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x8500
movq %rbx, %rdi
callq 0x27704
movq %r12, %rdi
callq 0x87c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/include/cpp_utils/thread_pool.hpp
// Function: cpp::default_thread_pool<std::deque>::wait()
void wait() {
        while (true) {
            std::unique_lock<std::mutex> ulock(main_lock);

            if (tasks.empty() && std::find(status.begin(), status.end(), thread_status::WORKING) == status.end()) {
                return;
            }

            //At this point, there are still some threads working, we wait for
            //one of them to notify a change of status
            wait_condition.wait(ulock, [this] {
                return tasks.empty();
            });
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x80(%rdi), %r13
leaq 0xd8(%rdi), %r14
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r13, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %r15, %rdi
callq 0x278ee
movb $0x1, 0x18(%rsp)
movq 0x60(%rbx), %rax
cmpq 0x40(%rbx), %rax
jne 0x27fb0
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
movl $0x1, 0xc(%rsp)
movq %r12, %rdx
callq 0x28134
cmpq 0x20(%rbx), %rax
jne 0x27fb0
jmp 0x27fc4
movq %r14, %rdi
movq %r15, %rsi
callq 0x8120
movq 0x60(%rbx), %rax
cmpq 0x40(%rbx), %rax
jne 0x27fa5
movq %r15, %rdi
callq 0x276ae
jmp 0x27f64
leaq 0x10(%rsp), %rdi
callq 0x276ae
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x276ae
movq %rbx, %rdi
callq 0x87c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/include/cpp_utils/streams.hpp
// Function: std::ostream& cpp::operator<<<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>>>>(std::ostream&, 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&)
std::ostream& operator<<(std::ostream& os, const std::vector<T, A>& vec) {
    os << "[";
    std::string comma;
    for (auto& v : vec) {
        os << comma << v;
        comma = ", ";
    }
    os << "]";
    return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x282c6(%rip), %rsi     # 0x64caf
movl $0x1, %edx
callq 0x8560
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq (%r14), %r13
movq 0x8(%r14), %rbp
cmpq %rbp, %r13
je 0x3ca66
leaq 0x29671(%rip), %r14     # 0x6608f
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x8560
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rax, %rdi
callq 0x8560
movq 0x10(%rsp), %rdx
movl $0x2, %r8d
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x39766
addq $0x20, %r13
cmpq %rbp, %r13
jne 0x3ca23
leaq 0x28284(%rip), %rsi     # 0x64cf1
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8560
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3ca91
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8500
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3caa5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3cabf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8500
movq %rbx, %rdi
callq 0x87c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/include/cpp_utils/string.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>& cpp::ltrim<char, std::char_traits<char>, std::allocator<char>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::basic_string<CharT, Traits, Allocator>& ltrim(std::basic_string<CharT, Traits, Allocator>& s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
									[](CharT c) {
										return !std::isspace(c);
									}));
    return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rsi
addq %r14, %rsi
movq %r14, %rdi
callq 0x3f8ff
movq (%rbx), %rcx
movq %r14, %rsi
subq %rcx, %rsi
movq 0x8(%rbx), %rdx
addq %rcx, %rdx
cmpq %rax, %rdx
je 0x3f651
subq %r14, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0x3f89e
jmp 0x3f659
movq %rsi, 0x8(%rbx)
movb $0x0, (%rcx,%rsi)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/doctest/doctest/doctest.h
// Function: doctest::skipPathFromFilename(char const*)
const char* skipPathFromFilename(const char* file) {
#ifndef DOCTEST_CONFIG_DISABLE
    if(getContextOptions()->no_path_in_filenames) {
        auto back    = std::strrchr(file, '\\');
        auto forward = std::strrchr(file, '/');
        if(back || forward) {
            if(back > forward)
                forward = back;
            return forward + 1;
        }
    }
#endif // DOCTEST_CONFIG_DISABLE
    return file;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x426b5(%rip), %rax     # 0x83668
cmpb $0x1, 0x7c(%rax)
jne 0x40feb
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x8550
movq %rax, %r14
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x8550
cmpq %rax, %r14
movq %rax, %rcx
cmovaq %r14, %rcx
orq %rax, %r14
je 0x40feb
incq %rcx
movq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/doctest/doctest/doctest.h
// Function: doctest::SubcaseSignature::operator<(doctest::SubcaseSignature const&) const
bool SubcaseSignature::operator<(const SubcaseSignature& other) const {
    if(m_line != other.m_line)
        return m_line < other.m_line;
    if(std::strcmp(m_file, other.m_file) != 0)
        return std::strcmp(m_file, other.m_file) < 0;
    return m_name.compare(other.m_name) < 0;
}

// Assembly:
movl 0x20(%rsi), %eax
cmpl %eax, 0x20(%rdi)
jne 0x410a0
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq 0x18(%rsi), %rsi
callq 0x8660
testl %eax, %eax
jne 0x41095
cmpb $0x0, 0x17(%rbx)
jns 0x41080
movq (%rbx), %rbx
cmpb $0x0, 0x17(%r14)
jns 0x4108a
movq (%r14), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8660
shrl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
setl %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]cpp_utils_test/doctest/doctest/doctest.h
// Function: doctest::Approx::operator()(double) const
Approx Approx::operator()(double value) const {
    Approx approx(value);
    approx.epsilon(m_epsilon);
    approx.scale(m_scale);
    return approx;
}

// Assembly:
movq %rdi, %rax
vmovaps 0x23d9b(%rip), %xmm1    # 0x65170
vmovups %xmm1, (%rdi)
vmovsd %xmm0, 0x10(%rdi)
vmovups (%rsi), %xmm0
vmovups %xmm0, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/SeanChao[P]KV-Store/persistence.cc
// Function: PersistenceTest::start_test(void*)
void start_test(void *args = NULL) override
	{
		bool testmode = (args && *static_cast<bool *>(args));

		std::cout << "KVStore Persistence Test" << std::endl;

		if (testmode) {
			std::cout << "<<Test Mode>>" << std::endl;
			test(TEST_MAX);
		} else {
			std::cout << "<<Preparation Mode>>" << std::endl;
			prepare(TEST_MAX);
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3e5f
movb (%rsi), %bpl
movq 0xb204(%rip), %r14      # 0xefd0
leaq 0x73f0(%rip), %rsi      # 0xb1c3
movl $0x18, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
cmpb $0x1, %bpl
jne 0x3ea1
leaq 0x73c4(%rip), %rsi      # 0xb1dc
movl $0xd, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq 0xa8(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3f3a
movq 0xb16a(%rip), %r14      # 0xefd0
leaq 0x7356(%rip), %rsi      # 0xb1c3
movl $0x18, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq 0xb128(%rip), %r14      # 0xefd0
leaq 0x733b(%rip), %rsi      # 0xb1ea
movl $0x14, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq 0xa8(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x420c
// File: /workspace/github_cpp_makefile_star2_O1/SeanChao[P]KV-Store/./test.h
// Function: void Test::expect<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void expect(const T &exp, const T &got,
		    const std::string &file, int line)
	{
		++nr_tests;
		if (exp == got) {
			++nr_passed_tests;
			return;
		}
		if (verbose) {
			std::cerr << "TEST Error @" << file << ":" << line;
			std::cerr << ", expected " << exp;
			std::cerr << ", got " << got << std::endl;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r15
incq 0x8(%rdi)
movq %rsi, %r14
movq 0x8(%rsi), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4ac3
testq %rdx, %rdx
je 0x4b96
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x3290
testl %eax, %eax
je 0x4b96
cmpb $0x1, 0xa0(%r15)
jne 0x4b9a
movq 0xa518(%rip), %r15      # 0xeff0
leaq 0x672f(%rip), %rsi      # 0xb20e
movl $0xc, %edx
movq %r15, %rdi
callq 0x32b0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x32b0
movq %rax, %r12
leaq 0x65f6(%rip), %rsi      # 0xb0fd
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
movq %r12, %rdi
movl %ebp, %esi
callq 0x33d0
leaq 0x66f6(%rip), %rsi      # 0xb21b
movl $0xb, %edx
movq %r15, %rdi
callq 0x32b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x32b0
leaq 0x66df(%rip), %rsi      # 0xb227
movl $0x6, %edx
movq %r15, %rdi
callq 0x32b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x32b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31b0
incq 0x10(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/SeanChao[P]KV-Store/./test.h
// Function: Test::phase()
void phase(void)
	{
		// Report
		std::cout << "  Phase " << (nr_phases+1) << ": ";
		std::cout << nr_passed_tests << "/" << nr_tests << " ";

		// Count
		++nr_phases;
		if (nr_tests == nr_passed_tests) {
			++nr_passed_phases;
			std::cout << "[PASS]" << std::endl;
		} else
			std::cout << "[FAIL]" << std::endl;

		std::cout.flush();

		// Reset
		nr_tests = 0;
		nr_passed_tests = 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xa41a(%rip), %rbx      # 0xefd0
leaq 0x6671(%rip), %rsi      # 0xb22e
movl $0x8, %edx
movq %rbx, %rdi
callq 0x32b0
movq 0x18(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x31a0
leaq 0x6449(%rip), %rsi      # 0xb029
movl $0x2, %edx
movq %rax, %rdi
callq 0x32b0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x31a0
movq %rax, %r15
leaq 0x6634(%rip), %rsi      # 0xb237
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
leaq 0x8(%r14), %r12
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x31a0
leaq 0x66ca(%rip), %rsi      # 0xb2f1
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
incq 0x18(%r14)
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jne 0x4c4f
incq 0x20(%r14)
leaq 0x65ec(%rip), %rsi      # 0xb239
jmp 0x4c56
leaq 0x65ea(%rip), %rsi      # 0xb240
movl $0x6, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq %rbx, %rdi
callq 0x31b0
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/SeanChao[P]KV-Store/./test.h
// Function: Test::report()
void report(void)
	{
		std::cout << nr_passed_phases << "/" << nr_phases << " passed.";
		std::cout << std::endl;
		std::cout.flush();

		nr_phases = 0;
		nr_passed_phases = 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
movq 0xa317(%rip), %r14      # 0xefd0
movq %r14, %rdi
callq 0x31a0
movq %rax, %r15
leaq 0x656c(%rip), %rsi      # 0xb237
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x31a0
leaq 0x655c(%rip), %rsi      # 0xb247
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x31b0
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::KVStore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
KVStore::KVStore(const std::string &dir)
    : KVStoreAPI(dir), dir(dir), verbose(false), memTableSize(0), level(0) {
    memTable = std::unique_ptr<SkipList<uint64_t, std::string>>(
        new SkipList<uint64_t, std::string>());
    // this->dir = dir;
    // root = std::filesystem::path(dir);
    fileNum.push_back(0);
    loadSsTable();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
leaq 0x9d84(%rip), %rax      # 0xec50
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9582
movb $0x0, 0x28(%r15)
leaq 0x38(%r15), %r14
leaq 0x60(%r15), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r15)
movq $0x0, 0x70(%r15)
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x40(%r15)
movups %xmm0, 0x4c(%r15)
movl $0x28, %edi
callq 0x3270
movq %rax, %rbp
movq %rax, %rdi
callq 0x84ac
movq $0x0, 0x10(%rsp)
movq (%r14), %rsi
movq %rbp, (%r14)
testq %rsi, %rsi
je 0x4f4d
movq %r14, %rdi
callq 0x93d4
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x4f61
leaq 0x10(%rsp), %rdi
callq 0x93d4
movl $0x0, 0xc(%rsp)
movq 0x68(%r15), %rsi
cmpq 0x70(%r15), %rsi
je 0x4f83
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x68(%r15)
jmp 0x4f90
leaq 0xc(%rsp), %rdx
movq %r12, %rdi
callq 0x9766
movq %r15, %rdi
callq 0x5018
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4fbe
jmp 0x4fbe
movq %rax, (%rsp)
movl $0x28, %esi
movq %rbp, %rdi
callq 0x3280
jmp 0x4fc2
movq %rax, (%rsp)
leaq 0x40(%r15), %rbp
movq (%r12), %rdi
testq %rdi, %rdi
je 0x4fdb
movq 0x70(%r15), %rsi
subq %rdi, %rsi
callq 0x3280
movq %rbp, %rdi
callq 0x8622
movq (%r14), %rsi
testq %rsi, %rsi
je 0x4ff3
movq %r14, %rdi
callq 0x93d4
movq $0x0, (%r14)
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x500e
movq (%r13), %rsi
incq %rsi
callq 0x3280
movq (%rsp), %rdi
callq 0x33f0
nop