LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/eugene87222[P]Game-of-Life/gol.cpp
// Function: Simkinglidergun(int, int)
void Simkinglidergun(int height, int width) {
    emptyBoard(height, width);

    board[21][2] = 1;
    board[22][2] = 1;
    board[21][3] = 1;
    board[22][3] = 1;

    board[18][6] = 1;
    board[19][6] = 1;
    board[18][7] = 1;
    board[19][7] = 1;

    board[21][9] = 1;
    board[22][9] = 1;
    board[21][10] = 1;
    board[22][10] = 1;

    board[4][22] = 1;
    board[5][22] = 1;
    board[3][23] = 1;
    board[5][23] = 1;
    board[3][24] = 1;
    board[2][25] = 1;
    board[3][25] = 1;

    board[10][23] = 1;
    board[11][23] = 1;
    board[12][23] = 1;
    board[10][24] = 1;
    board[13][24] = 1;
    board[10][25] = 1;
    board[13][25] = 1;
    board[13][27] = 1;
    board[9][28] = 1;
    board[13][28] = 1;
    board[10][29] = 1;
    board[12][29] = 1;
    board[11][30] = 1;

    board[10][33] = 1;
    board[11][33] = 1;
    board[10][34] = 1;
    board[11][34] = 1;
}

// Assembly:
pushq %rax
callq 0x2497
movq 0x3a95(%rip), %rcx      # 0x6178
movq 0x1f8(%rcx), %rdx
movl $0x1, %eax
movl %eax, 0x8(%rdx)
movq 0x210(%rcx), %rsi
movl %eax, 0x8(%rsi)
movl %eax, 0xc(%rdx)
movl %eax, 0xc(%rsi)
movq 0x1b0(%rcx), %rdi
movl %eax, 0x18(%rdi)
movq 0x1c8(%rcx), %r8
movl %eax, 0x18(%r8)
movl %eax, 0x1c(%rdi)
movl %eax, 0x1c(%r8)
movl %eax, 0x24(%rdx)
movl %eax, 0x24(%rsi)
movl %eax, 0x28(%rdx)
movl %eax, 0x28(%rsi)
movq 0x60(%rcx), %rdx
movl %eax, 0x58(%rdx)
movq 0x78(%rcx), %rdx
movl %eax, 0x58(%rdx)
movq 0x48(%rcx), %rsi
movl %eax, 0x5c(%rsi)
movl %eax, 0x5c(%rdx)
movl %eax, 0x60(%rsi)
movq 0x30(%rcx), %rdx
movl %eax, 0x64(%rdx)
movl %eax, 0x64(%rsi)
movq 0xf0(%rcx), %rdx
movl %eax, 0x5c(%rdx)
movq 0x108(%rcx), %rsi
movl %eax, 0x5c(%rsi)
movq 0x120(%rcx), %rdi
movl %eax, 0x5c(%rdi)
movl %eax, 0x60(%rdx)
movq 0x138(%rcx), %r8
movl %eax, 0x60(%r8)
movl %eax, 0x64(%rdx)
movl %eax, 0x64(%r8)
movl %eax, 0x6c(%r8)
movq 0xd8(%rcx), %rcx
movl %eax, 0x70(%rcx)
movl %eax, 0x70(%r8)
movl %eax, 0x74(%rdx)
movl %eax, 0x74(%rdi)
movl %eax, 0x78(%rsi)
movl %eax, 0x84(%rdx)
movl %eax, 0x84(%rsi)
movl %eax, 0x88(%rdx)
movl %eax, 0x88(%rsi)
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/eugene87222[P]Game-of-Life/gol.cpp
// Function: update_thd(int, int, int, int)
void update_thd(int h_begin, int h_end, int w_begin, int w_end) {
    for(int i = h_begin; i <= h_end; i++) {
        for(int j = w_begin; j <= w_end; j++) {
            int alive = board[i-1][j-1] + board[i-1][j] + board[i-1][j+1] + 
                        board[i][j-1] + board[i][j+1] + 
                        board[i+1][j-1] + board[i+1][j] + board[i+1][j+1];
            if(board[i][j] == 1) {
                if(alive != 2 && alive != 3) {
                    new_board[i][j] = 0;
                }
            }
            else {
                if(alive == 3){
                    new_board[i][j] = 1;
                }
            }
        }
    }
}

// Assembly:
cmpl %esi, %edi
jg 0x289e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x39a8(%rip), %rax      # 0x6178
leaq -0x18(%rax), %r8
movq %r8, -0x8(%rsp)
leaq 0x18(%rax), %r9
movslq %edx, %r8
movslq %edi, %rdi
incl %esi
leaq (,%r8,4), %r10
movl %ecx, %r11d
subl %r8d, %r11d
incl %r11d
cmpl %ecx, %edx
jg 0x2889
leaq (,%rdi,8), %r8
leaq (%r8,%r8,2), %r8
movq 0x397f(%rip), %rbx      # 0x6190
addq %r8, %rbx
movq -0x8(%rsp), %r14
movq (%r14,%r8), %r14
addq %r10, %r14
movq (%r9,%r8), %r15
addq %r10, %r15
movq (%rax,%r8), %r12
addq %r10, %r12
xorl %r13d, %r13d
movl (%r14,%r13,4), %ebp
addl -0x4(%r14,%r13,4), %ebp
addl 0x4(%r14,%r13,4), %ebp
addl -0x4(%r12,%r13,4), %ebp
addl 0x4(%r12,%r13,4), %ebp
addl -0x4(%r15,%r13,4), %ebp
addl (%r15,%r13,4), %ebp
addl 0x4(%r15,%r13,4), %ebp
cmpl $0x1, (%r12,%r13,4)
jne 0x286b
addl $-0x4, %ebp
xorl %r8d, %r8d
cmpl $-0x2, %ebp
jb 0x2876
jmp 0x2881
movl $0x1, %r8d
cmpl $0x3, %ebp
jne 0x2881
movq (%rbx), %rbp
addq %r10, %rbp
movl %r8d, (%rbp,%r13,4)
incq %r13
cmpl %r13d, %r11d
jne 0x2831
incq %rdi
cmpl %edi, %esi
jne 0x27f6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eugene87222[P]Game-of-Life/gol.cpp
// Function: update(int, int)
void update(int height, int width) {
    new_board = board;
    for(int i = 1; i < height+1; i++) {
        for(int j = 1; j < width+1; j++) {
            int alive = board[i-1][j-1] + board[i-1][j] + board[i-1][j+1] + 
                        board[i][j-1] + board[i][j+1] + 
                        board[i+1][j-1] + board[i+1][j] + board[i+1][j+1];
            if(board[i][j] == 1) {
                if(alive != 2 && alive != 3) {
                    new_board[i][j] = 0;
                }
            }
            else {
                if(alive == 3){
                    new_board[i][j] = 1;
                }
            }
        }
    }
    board = new_board;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
leaq 0x38da(%rip), %rdi      # 0x6190
leaq 0x38bb(%rip), %rsi      # 0x6178
callq 0x31c8
testl %r14d, %r14d
jle 0x296f
movq 0x38a6(%rip), %rax      # 0x6178
leaq -0x18(%rax), %rcx
leaq 0x18(%rax), %rdx
leal 0x1(%rbx), %esi
incl %r14d
movl $0x1, %edi
testl %ebx, %ebx
jle 0x2963
leaq (,%rdi,8), %r8
leaq (%r8,%r8,2), %r8
movq (%rcx,%r8), %r9
movq (%rax,%r8), %r10
movq (%rdx,%r8), %r11
addq 0x3888(%rip), %r8       # 0x6190
movl $0x1, %r15d
movl (%r9,%r15,4), %ebp
addl -0x4(%r9,%r15,4), %ebp
addl 0x4(%r9,%r15,4), %ebp
addl -0x4(%r10,%r15,4), %ebp
addl 0x4(%r10,%r15,4), %ebp
addl -0x4(%r11,%r15,4), %ebp
addl (%r11,%r15,4), %ebp
addl 0x4(%r11,%r15,4), %ebp
cmpl $0x1, (%r10,%r15,4)
jne 0x2948
addl $-0x4, %ebp
xorl %r12d, %r12d
cmpl $-0x2, %ebp
jb 0x2953
jmp 0x295b
movl $0x1, %r12d
cmpl $0x3, %ebp
jne 0x295b
movq (%r8), %r13
movl %r12d, (%r13,%r15,4)
incq %r15
cmpq %r15, %rsi
jne 0x290e
incq %rdi
cmpq %r14, %rdi
jne 0x28e5
leaq 0x3802(%rip), %rdi      # 0x6178
leaq 0x3813(%rip), %rsi      # 0x6190
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31c8
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: Solution::describe(_IO_FILE*) const
void Solution::describe(FILE * const fout) const
{
	assert(!empty());
	auto it = cbegin();
	fprintf(fout, "%s", it->c_str());
	while (++it != cend())
		fprintf(fout, "|%s", it->c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, 0x28(%rdi)
je 0x24b6
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq 0x20(%r15), %rdi
callq 0x2170
addq $0x8, %r14
movq %r15, %rdi
callq 0x2180
cmpq %r14, %rax
je 0x24ad
movq %rax, %r15
leaq 0x3c05(%rip), %r12      # 0x6091
movq 0x20(%r15), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21d0
movq %r15, %rdi
callq 0x2180
movq %rax, %r15
cmpq %r14, %rax
jne 0x248c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b93(%rip), %rdi      # 0x6050
leaq 0x3b95(%rip), %rsi      # 0x6059
leaq 0x3b9b(%rip), %rcx      # 0x6066
movl $0x5d, %edx
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: AnswerSequence::describe(_IO_FILE*) const
void AnswerSequence::describe(FILE * const fout) const
{
	if (!empty()) {
		auto it = cbegin();
		fprintf(fout, "%u", *it);
		while (++it != cend())
			fprintf(fout, ".%u", *it);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
cmpq 0x8(%rdi), %r12
je 0x2531
movq %rsi, %rbx
movq %rdi, %r14
movl (%r12), %edx
leaq 0x3b9b(%rip), %rsi      # 0x6096
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21d0
addq $0x4, %r12
cmpq 0x8(%r14), %r12
je 0x2531
leaq 0x3b7f(%rip), %r15      # 0x6095
movl (%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21d0
addq $0x4, %r12
cmpq 0x8(%r14), %r12
jne 0x2516
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: WordParser::parse(char)
bool WordParser::parse(char const ch)
{
	if (!isalpha(ch))
		return false;
	Word const bit = ascii_to_bit(ch);
	if ((accum_ & bit) != 0)
		return false;	// Words must have unique letters
	accum_ |= bit;
	cnt_++;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %edi
callq 0x2220
testl %eax, %eax
je 0x2577
andb $0x1f, %r14b
decb %r14b
movl $0x1, %edx
movl %r14d, %ecx
shll %cl, %edx
movl (%rbx), %ecx
testl %edx, %ecx
sete %al
jne 0x2579
orl %edx, %ecx
movl %ecx, (%rbx)
incl 0x4(%rbx)
movb $0x1, %al
jmp 0x2579
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: Dictionary::Dictionary(_IO_FILE*, unsigned int)
Dictionary::Dictionary(FILE * const dictionary_file, unsigned const word_length)
	: word_length_(word_length)
{
	// Build words_[] map filled with all of the
	// valid words of "word_length" all-unique letters
	{
		string w;
		while (read_uppercase_word(dictionary_file, &w)) {
			Word const g = string_to_bitmask(w.c_str(), word_length);
			if (g != 0)
				words_[g].insert(w);
		}
	}
	if (!words_.empty()) {
		// Compute the keys_[] vector
		keys_.reserve(words_.size());
		size_t total_words = 0;
		for (auto it = words_.cbegin(); it != words_.cend(); ++it) {
			total_words += it->second.size();
			keys_.push_back(it->first);
		}
#if 0
		fprintf(stderr, "Searching for %u (2^%lf) words (%u unique without anagrams)\n",
			static_cast<unsigned>(total_words),
			log(total_words) / M_LN2,
			static_cast<unsigned>(words_.size()));
#endif // 0
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rdi), %rcx
movl $0x0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rcx, -0x48(%rbp)
movq %rcx, 0x20(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, -0x40(%rbp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movl %edx, 0x48(%rdi)
leaq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
leaq -0x68(%rbp), %r13
leaq -0x2c(%rbp), %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x26dd
testb %al, %al
je 0x2624
movq -0x68(%rbp), %rdi
movl %r15d, %esi
callq 0x2749
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x25ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38de
movq %rax, %rdi
movq %r13, %rsi
callq 0x4356
jmp 0x25ea
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x2636
callq 0x2140
movq -0x40(%rbp), %rax
movq (%rax), %rsi
testq %rsi, %rsi
movq -0x38(%rbp), %r15
movq -0x48(%rbp), %r12
je 0x268f
movq %r15, %rdi
callq 0x3946
movq 0x18(%rbx), %r14
cmpq %r12, %r14
je 0x268f
leaq 0x20(%r14), %rdx
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x2677
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x267f
movq %r15, %rdi
callq 0x45d8
movq %r14, %rdi
callq 0x2180
movq %rax, %r14
cmpq %r12, %rax
jne 0x265b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26a0
movq %rax, %r14
jmp 0x26bc
jmp 0x26a7
movq %rax, %r14
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x26bc
callq 0x2140
movq -0x38(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x26cd
callq 0x2140
movq %rbx, %rdi
callq 0x3d2a
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: read_uppercase_word(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
static bool read_uppercase_word(FILE * const fin, string *destp)
{
	destp->clear();
	for (;;) {
		int const ch = getc(fin);
		if (ch == EOF)
			return !destp->empty();
		if (ch == '\n')
			return true;
		destp->push_back(toupper(ch));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x8(%rsi)
movq (%rsi), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x2070
cmpl $0xa, %eax
je 0x2718
cmpl $-0x1, %eax
jne 0x271f
cmpq $0x0, 0x8(%rbx)
setne %r15b
jmp 0x271b
movb $0x1, %r15b
xorl %eax, %eax
jmp 0x2733
movl %eax, %edi
callq 0x2270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2130
movb $0x1, %al
testb %al, %al
jne 0x26fb
andb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: string_to_bitmask(char const*, unsigned int)
static Word string_to_bitmask(char const *p, unsigned const word_length)
{
	WordParser parser;

	while (*p != '\0')
		if (!parser.parse(*p++))
			return 0;
	return parser.result(word_length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq -0x20(%rbp), %r15
movq $0x0, (%r15)
movb (%r14), %al
testb %al, %al
je 0x2780
incq %r14
movsbl %al, %esi
movq %r15, %rdi
callq 0x253a
testb %al, %al
jne 0x2763
xorl %eax, %eax
jmp 0x278a
xorl %eax, %eax
cmpl %ebx, -0x1c(%rbp)
jne 0x278a
movl -0x20(%rbp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: DividedWordList::build(Dictionary const&, std::vector<unsigned int, std::allocator<unsigned int>> const&, unsigned int)
void DividedWordList::build(Dictionary const& dictionary, Words const& ws, Word const guess)
{
	assert(size() == dictionary.wordLength() + 1);
	assert(!ws.empty());
	for (auto it = begin(); it != end(); ++it)
		it->clear();
	{
		auto it = ws.cbegin();
		do {
			unsigned const c = correct_letters(*it, guess);
			assert(c <= dictionary.wordLength());
			(*this)[c].update(dictionary, *it);
		} while (++it != ws.cend());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, -0x2c(%rbp)
movq %rdx, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
movl 0x48(%rsi), %edx
incl %edx
cmpq %rdx, %rcx
jne 0x28d4
movq (%r14), %rcx
cmpq 0x8(%r14), %rcx
je 0x28f3
movq %rsi, %r15
movq %rdi, %r12
cmpq 0x8(%r12), %rax
je 0x2849
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x283b
movq %rcx, 0x8(%rax)
movq $0x0, 0x18(%rax)
addq $0x20, %rax
jmp 0x2827
movq (%r14), %r13
movl $0x33333333, %ebx       # imm = 0x33333333
movl (%r13), %edx
movl %edx, %eax
andl -0x2c(%rbp), %eax
movl %eax, %ecx
shrl %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
subl %ecx, %eax
movl %eax, %ecx
andl %ebx, %ecx
shrl $0x2, %eax
andl %ebx, %eax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
addl %eax, %ecx
andl $0xf0f0f0f, %ecx        # imm = 0xF0F0F0F
imull $0x1010101, %ecx, %edi  # imm = 0x1010101
shrl $0x18, %edi
cmpl 0x48(%r15), %edi
ja 0x28b5
shll $0x5, %edi
addq (%r12), %rdi
movq %r15, %rsi
callq 0x2796
addq $0x4, %r13
cmpq 0x8(%r14), %r13
jne 0x2851
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x385a(%rip), %rdi      # 0x6116
leaq 0x3796(%rip), %rsi      # 0x6059
leaq 0x37f5(%rip), %rcx      # 0x60bf
movl $0x156, %edx            # imm = 0x156
callq 0x20c0
leaq 0x37be(%rip), %rdi      # 0x6099
leaq 0x3777(%rip), %rsi      # 0x6059
leaq 0x37d6(%rip), %rcx      # 0x60bf
movl $0x14e, %edx            # imm = 0x14E
callq 0x20c0
leaq 0x3810(%rip), %rdi      # 0x610a
leaq 0x3758(%rip), %rsi      # 0x6059
leaq 0x37b7(%rip), %rcx      # 0x60bf
movl $0x14f, %edx            # imm = 0x14F
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: DividedWordList::entropy() const
double DividedWordList::entropy() const
{
	size_t total_count = 0;
	bool perfect_split = true;
	for (auto it = cbegin(); it != cend(); ++it) {
		total_count += it->count();
		if (it->choices().size() > 1)
			perfect_split = false;
	}
	if (perfect_split) {
		// We can't do better than this -- by making this choice
		// we'll end up at the endgame
		return numeric_limits<double>::max();
	}
	double answer = 0.0;
	double const d_total = static_cast<double>(total_count);
	for (auto it = cbegin(); it != cend(); ++it)
		if (it->count() > 0) {
			double const prob = static_cast<double>(it->count()) / d_total;
			answer += prob * log(prob);
		}
	return -answer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rcx
cmpq %rcx, %r14
je 0x297b
movb $0x1, %al
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rdi
addq 0x18(%rdi), %rdx
movq 0x8(%rdi), %r8
subq (%rdi), %r8
cmpq $0x5, %r8
movzbl %al, %eax
cmovael %esi, %eax
addq $0x20, %rdi
cmpq %rcx, %rdi
jne 0x2935
movq %rdx, %xmm0
punpckldq 0x36b0(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x36b8(%rip), %xmm0     # 0x6020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, -0x30(%rbp)
jmp 0x2986
xorpd %xmm0, %xmm0
movapd %xmm0, -0x30(%rbp)
movb $0x1, %al
testb $0x1, %al
je 0x2994
movsd 0x36ae(%rip), %xmm0     # 0x6040
jmp 0x2a0c
cmpq 0x8(%rbx), %r14
je 0x2a00
xorpd %xmm0, %xmm0
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x29f4
movapd %xmm0, -0x20(%rbp)
movq %rax, %xmm1
punpckldq 0x3657(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x365f(%rip), %xmm1     # 0x6020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
divsd -0x30(%rbp), %xmm0
movapd %xmm0, -0x40(%rbp)
callq 0x2100
mulsd -0x40(%rbp), %xmm0
movapd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, -0x20(%rbp)
movapd -0x20(%rbp), %xmm0
addq $0x20, %r14
cmpq 0x8(%rbx), %r14
jne 0x299e
jmp 0x2a04
xorpd %xmm0, %xmm0
xorpd 0x3624(%rip), %xmm0     # 0x6030
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: SolutionPrinter::acceptBranch(AnswerSequence const&, unsigned int, double, DividedWordList const&)
void SolutionPrinter::acceptBranch(AnswerSequence const& sequence, Word const word, double const entropy, DividedWordList const& divided)
{
	sequence.describe(fout_);
	fputs(",N,", fout_);
	dict_.describeWord(fout_, word);
	// For debugging, print the entropy and the counts
	if (entropy == numeric_limits<double>::max())
		fputs(",-,", fout_);
	else
		fprintf(fout_, ",%lf,", entropy);
	{
		auto it = divided.cbegin();
		fprintf(fout_, "%u", static_cast<unsigned>(it->count()));
		while (++it != divided.cend())
			fprintf(fout_, "/%u", static_cast<unsigned>(it->count()));
	}
	putc('\n', fout_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movsd %xmm0, -0x28(%rbp)
movl %edx, %r15d
movq %rsi, %rax
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rax, %rdi
callq 0x24d6
movq 0x10(%r14), %rsi
leaq 0x3566(%rip), %rdi      # 0x61f9
callq 0x2170
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
movl %r15d, %edx
callq 0x3aca
movsd -0x28(%rbp), %xmm0
ucomisd 0x338b(%rip), %xmm0     # 0x6040
movq 0x10(%r14), %rsi
jne 0x2ccb
jp 0x2ccb
leaq 0x3539(%rip), %rdi      # 0x61fd
callq 0x2170
jmp 0x2cdf
leaq 0x352f(%rip), %rax      # 0x6201
movq %rsi, %rdi
movq %rax, %rsi
movb $0x1, %al
callq 0x21d0
movq (%rbx), %r12
movq 0x10(%r14), %rdi
movl 0x18(%r12), %edx
leaq 0x33a4(%rip), %rsi      # 0x6096
xorl %eax, %eax
callq 0x21d0
addq $0x20, %r12
cmpq 0x8(%rbx), %r12
je 0x2d27
leaq 0x34fd(%rip), %r15      # 0x6207
movq 0x10(%r14), %rdi
movl 0x18(%r12), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x21d0
addq $0x20, %r12
cmpq 0x8(%rbx), %r12
jne 0x2d0a
movq 0x10(%r14), %rsi
movl $0xa, %edi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: SolutionPrinter::acceptSolution(AnswerSequence const&, unsigned int)
void SolutionPrinter::acceptSolution(AnswerSequence const& sequence, Word const word)
{
	sequence.describe(fout_);
	fputs(",Y,", fout_);
	dict_.describeWord(fout_, word);
	fputs(",,\n", fout_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %rax
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rax, %rdi
callq 0x24d6
movq 0x10(%r14), %rsi
leaq 0x34a3(%rip), %rdi      # 0x620b
callq 0x2170
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
movl %ebx, %edx
callq 0x3aca
movq 0x10(%r14), %rsi
leaq 0x3488(%rip), %rdi      # 0x620f
popq %rbx
popq %r14
popq %rbp
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: SolutionTree::acceptSolution(AnswerSequence const&, unsigned int)
void SolutionTree::acceptSolution(AnswerSequence const& sequence, Word const word)
{
	string key;
	for (auto it = sequence.cbegin(); it != sequence.cend(); ++it)
		append_unsigned_period(&key, *it);
	assert(map_.find(key) == map_.end());
	map_[key] = word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rsi), %r14
cmpq 0x8(%rsi), %r14
je 0x2e82
movq %rsi, %r15
leaq 0x36a8(%rip), %r12      # 0x64f5
leaq -0xc0(%rbp), %r13
leaq -0x58(%rbp), %rbx
movl (%r14), %ecx
movl $0x64, %esi
movq %r13, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2280
addq $0x4, %r14
cmpq 0x8(%r15), %r14
jne 0x2e58
movq -0x38(%rbp), %r14
leaq 0x8(%r14), %rbx
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x46f2
addq $0x10, %r14
cmpq %r14, %rax
jne 0x2ed4
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x3b3c
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2ec2
callq 0x2140
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3338(%rip), %rdi      # 0x6213
leaq 0x3177(%rip), %rsi      # 0x6059
leaq 0x3347(%rip), %rcx      # 0x6230
movl $0x207, %edx            # imm = 0x207
callq 0x20c0
jmp 0x2ef7
jmp 0x2ef7
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2f0c
callq 0x2140
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/mitchblank[P]qiksolve/qiksolve.cpp
// Function: main
int main(int argn, char const * const *argv)
{
	if (argn < 2)
		return usage(argv[0]);
	unsigned a = 1;
	enum {
		INTERACTIVE,
		SOLUTION_TREE,
		BATCH
	} mode = INTERACTIVE;
	if (0 == strcmp(argv[1], "-t")) {
		mode = SOLUTION_TREE;
		a = 2;
		argn--;
	} else if (0 == strcmp(argv[1], "-b")) {
		mode = BATCH;
		a = 2;
		argn--;
	}
	if (argn < 2 || argn > 3)
		return usage(argv[0]);
	FILE *fp = fopen(argv[a], "r");
	if (fp == NULL) {
		perror("open");
		return 4;
	}
	Dictionary dict(fp, (argn == 2) ? 4 : static_cast<unsigned>(atoi(argv[a + 1])));
	if (dict.empty()) {
		fprintf(stderr, "%s: No words found!\n", argv[0]);
		return 1;
	}
	switch (mode) {
	case INTERACTIVE:
		dict.interactive();
		break;
	case BATCH:
		dict.batch(stdin, stdout);
		break;
	default:
		assert(mode == SOLUTION_TREE);
		dict.printSolutions(stdout);
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x3870
movl %edi, %r15d
movq 0x8(%rbx), %r12
leaq 0x2cb1(%rip), %rsi      # 0x63fe
movq %r12, %rdi
callq 0x21c0
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x377a
leaq 0x2c9e(%rip), %rsi      # 0x6401
movq %r12, %rdi
callq 0x21c0
testl %eax, %eax
je 0x378b
movl $0x1, %r14d
xorl %r13d, %r13d
jmp 0x379a
decl %r15d
movl $0x2, %r14d
movl $0x1, %r13d
jmp 0x379a
decl %r15d
movl $0x2, %r14d
movl $0x2, %r13d
leal -0x4(%r15), %eax
cmpl $-0x3, %eax
jbe 0x387a
movq (%rbx,%r14,8), %rdi
leaq 0x2c52(%rip), %rsi      # 0x6404
callq 0x21a0
testq %rax, %rax
je 0x3889
movq %rax, %r12
movl $0x4, %edx
cmpl $0x2, %r15d
je 0x37da
movq 0x8(%rbx,%r14,8), %rdi
callq 0x2200
movl %eax, %edx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x257e
cmpq $0x0, 0x28(%r15)
je 0x389c
cmpl $0x2, %r13d
je 0x380e
testl %r13d, %r13d
jne 0x382d
leaq -0x50(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x3274
jmp 0x3846
movq 0x57c3(%rip), %rax      # 0x8fd8
movq (%rax), %rsi
movq 0x57a1(%rip), %rax      # 0x8fc0
movq (%rax), %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f14
jmp 0x3846
cmpl $0x0, -0x2c(%rbp)
jne 0x38ab
movq 0x5786(%rip), %rax      # 0x8fc0
movq (%rax), %rsi
leaq -0x80(%rbp), %rdi
callq 0x2d90
xorl %ebx, %ebx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3856
callq 0x2140
leaq -0x80(%rbp), %rdi
callq 0x3d2a
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x22f7
jmp 0x3882
movq %rbx, %rdi
callq 0x22d4
movl $0x8, %ebx
jmp 0x385f
leaq 0x2b76(%rip), %rdi      # 0x6406
callq 0x2120
movl $0x4, %ebx
jmp 0x385f
movq %rbx, %rdi
callq 0x22b0
movl $0x1, %ebx
jmp 0x3848
leaq 0x2b6e(%rip), %rdi      # 0x6420
leaq 0x27a0(%rip), %rsi      # 0x6059
leaq 0x2b76(%rip), %rcx      # 0x6436
movl $0x2bc, %edx            # imm = 0x2BC
callq 0x20c0
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3cc2
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite3-async-test.cc
// Function: main
int main(int argc, char **args) {
    const char *env_path = getenv("SQLITE_TEST_DB");
    Sqlite3 sq(env_path ? env_path : "/tmp/test.db",
               getenv("KVSTORE_AUDITABLE"));
    QueuedKVStore thing(&sq);

    TestSuite suite(&thing);
    return suite.run() ? 0 : 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq 0x68d5(%rip), %rdi      # 0xb004
callq 0x4330
testq %rax, %rax
leaq 0x68d5(%rip), %rbx      # 0xb013
cmovneq %rax, %rbx
leaq 0x68d7(%rip), %rdi      # 0xb020
callq 0x4330
movq %rax, %r14
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5efa
leaq 0xc310(%rip), %rax      # 0x10a78
addq $0x10, %rax
testq %r14, %r14
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq $0x0, 0x30(%r15)
setne 0x19(%r15)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movl $0xf4240, %edx          # imm = 0xF4240
callq 0x4864
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x81c0
movq %rsp, %rdi
callq 0x83c2
xorb $0x1, %al
movzbl %al, %ebx
movq %rsp, %rdi
callq 0x8342
leaq 0x20(%rsp), %rdi
callq 0x4928
leaq 0x48(%rsp), %rdi
callq 0x65e6
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8342
jmp 0x47ee
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4928
jmp 0x47fd
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x65e6
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/./async.hh
// Function: kvtest::launch_executor_thread(void*)
static void* launch_executor_thread(void* arg) {
        AsyncExecutor *executor = (AsyncExecutor*) arg;
        try {
            executor->run();
        } catch(...) {
            std::cerr << "Caught a fatal exception in the thread" << std::endl;
        }
        return NULL;
    }

// Assembly:
pushq %rbx
callq 0x4e46
xorl %eax, %eax
popq %rbx
retq
movq %rax, %rdi
callq 0x40d0
movq 0xc7c0(%rip), %rdi      # 0x10fe8
leaq 0x6823(%rip), %rsi      # 0xb052
movl $0x26, %edx
callq 0x42f0
movq 0xc7a8(%rip), %rdi      # 0x10fe8
callq 0x40f0
callq 0x4400
jmp 0x4815
movq %rax, %rbx
callq 0x4400
movq %rbx, %rdi
callq 0x4450
movq %rax, %rdi
callq 0x4e1f
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/./async.hh
// Function: kvtest::QueuedKVStore::QueuedKVStore(kvtest::KVStore*, int)
QueuedKVStore(KVStore *t, int max_drain=DEFAULT_MAX_DRAIN) {
            tut = t;
            iq = new AsyncQueue(max_drain);
            executor = new AsyncExecutor(tut, iq);

            if(pthread_create(&thread, NULL, launch_executor_thread, executor)
               != 0) {
                throw std::runtime_error("Error initializing queue thread");
            }
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
leaq 0xbe7c(%rip), %rax      # 0x106f0
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movl $0xb0, %edi
callq 0x42c0
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x49c6
movq %r14, 0x10(%rbx)
movl $0x10, %edi
callq 0x42c0
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %rax, 0x18(%rbx)
addq $0x20, %rbx
leaq -0xab(%rip), %rdx       # 0x480f
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0x4470
testl %eax, %eax
jne 0x48d0
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x4100
movq %rax, %r14
leaq 0x674e(%rip), %rsi      # 0xb032
movq %rax, %rdi
callq 0x40c0
movq 0xc6fd(%rip), %rsi      # 0x10ff0
movq 0xc6be(%rip), %rdx      # 0x10fb8
movq %r14, %rdi
callq 0x4420
movq %rax, %rbx
movq %r14, %rdi
callq 0x41d0
jmp 0x491f
movq %rax, %rbx
movl $0xb0, %esi
movq %r14, %rdi
callq 0x42d0
movq %rbx, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/./async.hh
// Function: kvtest::QueuedKVStore::~QueuedKVStore()
~QueuedKVStore() {
            executor->stop();
            pthread_join(thread, NULL);
            delete executor;
            delete iq;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xbdba(%rip), %rax      # 0x106f0
movq %rax, (%rdi)
movq 0x18(%rdi), %rax
movq 0x8(%rax), %r14
movl $0x8, %edi
callq 0x42c0
leaq 0xc086(%rip), %rcx      # 0x109d8
movq %rcx, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x54dc
movq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0x4250
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x497e
movl $0x10, %esi
callq 0x42d0
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x49b6
leaq 0x30(%rbx), %rdi
callq 0x44a0
leaq 0x8(%rbx), %rdi
callq 0x4300
leaq 0x60(%rbx), %rdi
callq 0x53ec
movl $0xb0, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x4e1f
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/./async.hh
// Function: kvtest::QueuedKVStore::reset()
void reset() {
            std::queue<AsyncOperation*> opq;
            RememberingCallback<bool> cb;
            iq->addOperation(new ResetOperation(&cb));
            cb.waitForValue();
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x4cc6
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x543c
movq 0x10(%rbx), %rbx
movl $0x10, %edi
callq 0x42c0
movq %r14, 0x8(%rax)
leaq 0xbd8b(%rip), %rcx      # 0x10818
movq %rcx, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54dc
leaq 0x8(%rsp), %rdi
callq 0x55ba
leaq 0xbd1c(%rip), %rax      # 0x107c8
leaq 0x18(%rsp), %rdi
movq %rax, -0x10(%rdi)
callq 0x4300
leaq 0x40(%rsp), %rdi
callq 0x44a0
leaq 0x70(%rsp), %rdi
callq 0x53ec
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x4b00
movq %rax, %rbx
leaq 0xbce0(%rip), %rax      # 0x107c8
leaq 0x18(%rsp), %rdi
movq %rax, -0x10(%rdi)
callq 0x4300
leaq 0x40(%rsp), %rdi
callq 0x44a0
leaq 0x70(%rsp), %rdi
callq 0x53ec
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/./async.hh
// Function: kvtest::AsyncExecutor::run()
void run() {
            try {
                while(true) {
                    std::queue<AsyncOperation*> ops;
                    iq->drainTo(ops);
                    tut->begin();
                    int count = 0;

                    while(!ops.empty()) {
                        AsyncOperation *op = ops.front();
                        ops.pop();

                        op->execute(tut);
                        count++;
                        delete op;
                    }

                    tut->commit();
                }
            } catch(AsyncShutdownOperation *op) {
                delete op;
                std::cerr << "Shutting down..." << std::endl;
            } catch(std::runtime_error &e) {
                std::cerr << "Exception in executor loop: "
                          << e.what() << std::endl;
                abort();
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rsp, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x4cc6
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x5012
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x10(%rsp), %rax
cmpq %rax, 0x30(%rsp)
je 0x4f00
movq (%rax), %r15
movq 0x20(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x4eb2
addq $0x8, %rax
jmp 0x4ee4
movq 0x18(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x42d0
movq 0x28(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movq (%rbx), %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
jmp 0x4e8f
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %r14, %rdi
callq 0x53ec
jmp 0x4e55
jmp 0x4f22
movq %rdx, %r14
movq %rax, %rbx
jmp 0x4f30
jmp 0x4f22
movq %rdx, %r14
movq %rax, %rbx
movq %rsp, %rdi
callq 0x53ec
cmpl $0x2, %r14d
jne 0x4fa1
movq %rbx, %rdi
callq 0x40d0
testq %rax, %rax
je 0x4f4c
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq 0xc095(%rip), %rbx      # 0x10fe8
leaq 0x613c(%rip), %rsi      # 0xb096
movl $0x10, %edx
movq %rbx, %rdi
callq 0x42f0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x4290
movsbl %al, %esi
movq 0xc063(%rip), %rdi      # 0x10fe8
callq 0x4040
movq %rax, %rdi
callq 0x41a0
callq 0x4400
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x1, %r14d
jne 0x5009
movq %rbx, %rdi
callq 0x40d0
movq %rax, %rbx
movq 0xc02f(%rip), %rdi      # 0x10fe8
leaq 0x60b9(%rip), %rsi      # 0xb079
movl $0x1c, %edx
callq 0x42f0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0xc00e(%rip), %rdi      # 0x10fe8
movq %rax, %rsi
callq 0x42b0
movq %rax, %rdi
callq 0x40f0
callq 0x4160
movq %rax, %rbx
callq 0x4400
jmp 0x5009
movq %rax, %rdi
callq 0x4e1f
movq %rax, %rbx
callq 0x4400
movq %rbx, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/./async.hh
// Function: kvtest::AsyncQueue::drainTo(std::queue<kvtest::AsyncOperation*, std::deque<kvtest::AsyncOperation*, std::allocator<kvtest::AsyncOperation*>>>&)
void drainTo(std::queue<AsyncOperation*> &out) {
            LockHolder lh(&mutex);
            if(ops.empty()) {
                if(pthread_cond_wait(&cond, &mutex) != 0) {
                    throw std::runtime_error("Error waiting for signal.");
                }
            }
            for(int i = 0; i < max_drain_ && !ops.empty(); i++) {
                out.push(ops.front());
                ops.pop();
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x5122
movq 0x90(%r14), %rax
cmpq 0x70(%r14), %rax
jne 0x5050
leaq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x43b0
testl %eax, %eax
jne 0x50bf
cmpl $0x0, (%r14)
jle 0x509e
leaq 0x60(%r14), %r15
xorl %ebp, %ebp
movq 0x70(%r14), %rsi
cmpq %rsi, 0x90(%r14)
je 0x509e
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5087
movq (%rsi), %rcx
movq %rcx, (%rax)
addq $0x8, 0x30(%rbx)
jmp 0x508f
movq %rbx, %rdi
callq 0x518a
movq %r15, %rdi
callq 0x539e
incl %ebp
cmpl (%r14), %ebp
jl 0x505c
cmpb $0x0, 0x10(%rsp)
jne 0x50b4
movq 0x8(%rsp), %rdi
callq 0x41f0
movb $0x1, 0x10(%rsp)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4100
movq %rax, %r14
leaq 0x5fd4(%rip), %rsi      # 0xb0a7
movq %rax, %rdi
callq 0x40c0
movq 0xbf0e(%rip), %rsi      # 0x10ff0
movq 0xbecf(%rip), %rdx      # 0x10fb8
movq %r14, %rdi
callq 0x4420
movq %rax, %rbx
movq %r14, %rdi
callq 0x41d0
jmp 0x5103
jmp 0x5100
movq %rax, %rbx
cmpb $0x0, 0x10(%rsp)
jne 0x5119
movq 0x8(%rsp), %rdi
callq 0x41f0
movb $0x1, 0x10(%rsp)
movq %rbx, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/./async.hh
// Function: kvtest::AsyncQueue::addOperation(kvtest::AsyncOperation*)
void addOperation(AsyncOperation *op) {
            LockHolder lh(&mutex);
            ops.push(op);
            if(pthread_cond_signal(&cond) != 0) {
                throw std::runtime_error("Error signaling change.");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
leaq 0x8(%rdi), %rsi
movq %rsp, %rdi
callq 0x5122
movq 0x90(%rbx), %rax
movq 0xa0(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5520
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x90(%rbx)
jmp 0x552e
leaq 0x60(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x518a
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x4030
testl %eax, %eax
jne 0x555b
cmpb $0x0, 0x8(%rsp)
jne 0x5553
movq (%rsp), %rdi
callq 0x41f0
movb $0x1, 0x8(%rsp)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4100
movq %rax, %r14
leaq 0x5bf2(%rip), %rsi      # 0xb161
movq %rax, %rdi
callq 0x40c0
movq 0xba72(%rip), %rsi      # 0x10ff0
movq 0xba33(%rip), %rdx      # 0x10fb8
movq %r14, %rdi
callq 0x4420
movq %rax, %rbx
movq %r14, %rdi
callq 0x41d0
jmp 0x559d
movq %rax, %rbx
cmpb $0x0, 0x8(%rsp)
jne 0x55b2
movq (%rsp), %rdi
callq 0x41f0
movb $0x1, 0x8(%rsp)
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/threads/part3/condition_variables.cpp
// Function: consumer(int, BoundedBuffer&)
void consumer(int id, BoundedBuffer& buffer){
    for(int i = 0; i < 50; ++i){
        int value = buffer.fetch();
        std::cout << "Consumer " << id << " fetched " << value << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(250));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, (%rsp)
movl %edi, %ebp
xorl %ebx, %ebx
movq 0x2cbf(%rip), %r14      # 0x4fd8
leaq 0x8(%rsp), %r13
movq (%rsp), %rdi
callq 0x2656
movl %eax, %r15d
movl $0x9, %edx
movq %r14, %rdi
leaq 0xccb(%rip), %rsi       # 0x3004
callq 0x2140
movq %r14, %rdi
movl %ebp, %esi
callq 0x21a0
movq %rax, %r12
movl $0x9, %edx
movq %rax, %rdi
leaq 0xcb4(%rip), %rsi       # 0x300e
callq 0x2140
movq %r12, %rdi
movl %r15d, %esi
callq 0x21a0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq $0x0, 0x8(%rsp)
movq $0xee6b280, 0x10(%rsp)  # imm = 0xEE6B280
movq %r13, %rdi
movq %r13, %rsi
callq 0x2080
cmpl $-0x1, %eax
jne 0x23c0
callq 0x2050
cmpl $0x4, (%rax)
je 0x23a6
incl %ebx
cmpl $0x32, %ebx
jne 0x231e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/threads/part3/condition_variables.cpp
// Function: producer(int, BoundedBuffer&)
void producer(int id, BoundedBuffer& buffer){
    for(int i = 0; i < 75; ++i){
        buffer.deposit(i);
        std::cout << "Produced " << id << " produced " << i << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
xorl %r14d, %r14d
movq 0x2be1(%rip), %r15      # 0x4fd8
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movl %r14d, %esi
callq 0x26fa
movl $0x9, %edx
movq %r15, %rdi
leaq 0xc02(%rip), %rsi       # 0x3018
callq 0x2140
movq %r15, %rdi
movl %ebp, %esi
callq 0x21a0
movq %rax, %r13
movl $0xa, %edx
movq %rax, %rdi
leaq 0xbeb(%rip), %rsi       # 0x3022
callq 0x2140
movq %r13, %rdi
movl %r14d, %esi
callq 0x21a0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq $0x0, 0x8(%rsp)
movq $0x5f5e100, 0x10(%rsp)  # imm = 0x5F5E100
movq %r12, %rdi
movq %r12, %rsi
callq 0x2080
cmpl $-0x1, %eax
jne 0x249d
callq 0x2050
cmpl $0x4, (%rax)
je 0x2483
incl %r14d
cmpl $0x4b, %r14d
jne 0x23fc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/threads/part3/condition_variables.cpp
// Function: main
int main(){
    BoundedBuffer buffer(200);

    std::thread c1(consumer, 0, std::ref(buffer));
    std::thread c2(consumer, 1, std::ref(buffer));
    std::thread c3(consumer, 2, std::ref(buffer));
    std::thread p1(producer, 0, std::ref(buffer));
    std::thread p2(producer, 1, std::ref(buffer));

    c1.join();
    c2.join();
    c3.join();
    p1.join();
    p2.join();

    return 0;
}

// Assembly:
pushq %rbx
subq $0xe0, %rsp
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movl $0xc8, %esi
callq 0x27a4
leaq 0x18(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x20(%rsp), %rcx
movq %rbx, (%rcx)
leaq -0x1f1(%rip), %rsi      # 0x22fc
leaq 0x28(%rsp), %rdi
callq 0x2822
leaq 0x10(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x18(%rsp), %rcx
movq %rbx, (%rcx)
leaq -0x215(%rip), %rsi      # 0x22fc
leaq 0x20(%rsp), %rdi
callq 0x2822
leaq 0x8(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x10(%rsp), %rcx
movq %rbx, (%rcx)
leaq -0x239(%rip), %rsi      # 0x22fc
leaq 0x18(%rsp), %rdi
callq 0x2822
leaq 0x30(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x8(%rsp), %rcx
movq %rbx, (%rcx)
leaq -0x17f(%rip), %rsi      # 0x23da
leaq 0x10(%rsp), %rdi
callq 0x2822
leaq 0x3c(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x30(%rsp), %rcx
movq %rbx, (%rcx)
leaq -0x1a3(%rip), %rsi      # 0x23da
leaq 0x8(%rsp), %rdi
callq 0x2822
leaq 0x28(%rsp), %rdi
callq 0x2190
leaq 0x20(%rsp), %rdi
callq 0x2190
leaq 0x18(%rsp), %rdi
callq 0x2190
leaq 0x10(%rsp), %rdi
callq 0x2190
leaq 0x8(%rsp), %rdi
callq 0x2190
cmpq $0x0, 0x8(%rsp)
jne 0x2651
cmpq $0x0, 0x10(%rsp)
jne 0x2651
cmpq $0x0, 0x18(%rsp)
jne 0x2651
cmpq $0x0, 0x20(%rsp)
jne 0x2651
cmpq $0x0, 0x28(%rsp)
jne 0x2651
leaq 0x40(%rsp), %rdi
callq 0x28b8
xorl %eax, %eax
addq $0xe0, %rsp
popq %rbx
retq
jmp 0x261c
movq %rax, %rbx
jmp 0x2627
movq %rax, %rbx
jmp 0x262f
movq %rax, %rbx
jmp 0x2637
movq %rax, %rbx
jmp 0x263f
cmpq $0x0, 0x8(%rsp)
jne 0x2651
movq %rax, %rbx
cmpq $0x0, 0x10(%rsp)
jne 0x2651
cmpq $0x0, 0x18(%rsp)
jne 0x2651
cmpq $0x0, 0x20(%rsp)
jne 0x2651
cmpq $0x0, 0x28(%rsp)
jne 0x2651
leaq 0x40(%rsp), %rdi
callq 0x28b8
movq %rbx, %rdi
callq 0x21b0
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/threads/part3/condition_variables.cpp
// Function: BoundedBuffer::fetch()
int fetch(){
        std::unique_lock<std::mutex> l(lock);

        not_empty.wait(l, [this](){return count != 0; });

        int result = buffer[front];
        front = (front + 1) % capacity;
        --count;

        l.unlock();
        not_full.notify_one();

        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x291e
movb $0x1, 0x8(%r14)
cmpl $0x0, 0x14(%rbx)
jne 0x26a1
leaq 0x70(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2070
cmpl $0x0, 0x14(%rbx)
je 0x2690
movq (%rbx), %rax
movslq 0xc(%rbx), %rcx
movl (%rax,%rcx,4), %ebp
leal 0x1(%rcx), %eax
cltd
idivl 0x8(%rbx)
movl %edx, 0xc(%rbx)
decl 0x14(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x28e0
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x2908
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2908
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/threads/part3/condition_variables.cpp
// Function: BoundedBuffer::deposit(int)
void deposit(int data){
        std::unique_lock<std::mutex> l(lock);

        not_full.wait(l, [this](){return count != capacity; });

        buffer[rear] = data;
        rear = (rear + 1) % capacity;
        ++count;

        l.unlock();
        not_empty.notify_one();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x291e
movb $0x1, 0x8(%r14)
movl 0x14(%rbx), %eax
cmpl 0x8(%rbx), %eax
jne 0x274b
leaq 0x40(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2070
movl 0x14(%rbx), %eax
cmpl 0x8(%rbx), %eax
je 0x2738
movq (%rbx), %rax
movslq 0x10(%rbx), %rcx
movl %ebp, (%rax,%rcx,4)
movl 0x10(%rbx), %eax
incl %eax
cltd
idivl 0x8(%rbx)
movl %edx, 0x10(%rbx)
incl 0x14(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x28e0
addq $0x70, %rbx
movq %rbx, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x2908
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2908
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/shanet[P]Crypto-Example/crypto_file_example.cpp
// Function: main
int main(int argc, char **argv) {
  if(argc != 2) {
    fprintf(stderr, "Invalid number of arguments given.\nUsage: %s [input file]\n", argv[0]);
    return 1;
  }

  Crypto crypto;

  char *encryptedOutput = appendToString(argv[1], (char*)".enc");
  char *decryptedOutput = appendToString(argv[1], (char*)".dec");

  encryptFile(&crypto, argv[1], encryptedOutput);
  decryptFile(&crypto, encryptedOutput, decryptedOutput);

  free(encryptedOutput);
  free(decryptedOutput);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
cmpl $0x2, %edi
jne 0x3157
movq %rsp, %r12
movq %r12, %rdi
callq 0x2900
movq 0x8(%r15), %rdi
leaq 0xfca(%rip), %rsi       # 0x40c3
callq 0x3179
movq %rax, %rbx
movq 0x8(%r15), %rdi
leaq 0xfbc(%rip), %rsi       # 0x40c8
callq 0x3179
movq %rax, %r14
movq 0x8(%r15), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x31cd
movq %rsp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x328f
movq %rbx, %rdi
callq 0x22d0
movq %r14, %rdi
callq 0x22d0
movq %rsp, %rdi
callq 0x2ace
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x246a
movl $0x1, %eax
jmp 0x314b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2ace
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O1/shanet[P]Crypto-Example/crypto_file_example.cpp
// Function: appendToString(char*, char*)
char* appendToString(char *string, char *suffix) {
  char *appenedString = (char*)malloc(strlen(string) + strlen(suffix) + 1);

  if(appenedString == NULL) {
    fprintf(stderr, "Failed to allocate memory\n");
    exit(1);
  }

  sprintf(appenedString, "%s%s", string, suffix);
  return appenedString;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2130
movq %rax, %r15
movq %rbx, %rdi
callq 0x2130
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x2300
testq %rax, %rax
je 0x31c8
movq %rax, %r15
leaq 0x100d(%rip), %rsi      # 0x41bc
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x20a0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2488