LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ys1998[P]spsim/src/mem.cpp
// Function: MEM::tick()
void MEM::tick(){
	if(in->valid() && read){
		auto inp = in->read();
		i = std::get<0>(inp);
		in1 = std::get<1>(inp);
		in2 = std::get<2>(inp);
		i.MEM = CLOCK;
	    //std::cout<<CLOCK<<std::endl;
        if(i.is_valid()){
			if(std::get<0>(i.type()) == OPCODE["sw"]){
				DCache[in1] = in2;
				// std::cout<<i.text<<std::endl;
			}
			else{
				res = DCache[in1];
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq 0x80(%rax), %rdi
callq 0x6310
testb $0x1, %al
jne 0x1afdf
jmp 0x1b206
movq -0xd0(%rbp), %rax
testb $0x1, 0xb0(%rax)
je 0x1b206
movq -0xd0(%rbp), %rax
movq 0x80(%rax), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x62b0
movq -0xd8(%rbp), %rdi
callq 0x6360
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rdi
callq 0x6380
jmp 0x1b035
leaq -0x88(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x63e0
movq -0xe8(%rbp), %rdi
movq %rax, %rcx
movq -0xd0(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0xa4(%rax)
callq 0x6400
movq %rax, %rcx
movq -0xd0(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0xa8(%rax)
leaq 0x1423d(%rip), %rcx     # 0x2f2bc
movl (%rcx), %ecx
movq %rax, %rdi
addq $0x8, %rdi
movl %ecx, 0x50(%rax)
callq 0x6280
movb %al, -0xd9(%rbp)
jmp 0x1b098
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x1b0a7
jmp 0x1b1ea
movq -0xd0(%rbp), %rsi
addq $0x8, %rsi
leaq -0x9c(%rbp), %rdi
callq 0x105b0
jmp 0x1b0c0
leaq -0x9c(%rbp), %rdi
callq 0x6210
movl (%rax), %eax
movl %eax, -0xf4(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3490
movq -0xf0(%rbp), %rdx
leaq 0x6f28(%rip), %rsi      # 0x2201d
leaq -0xc0(%rbp), %rdi
callq 0x6020
jmp 0x1b103
leaq 0x141be(%rip), %rdi     # 0x2f2c8
leaq -0xc0(%rbp), %rsi
callq 0x5f40
movq %rax, -0x100(%rbp)
jmp 0x1b11f
movq -0x100(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x104(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x31e0
leaq -0xc1(%rbp), %rdi
callq 0x3300
movl -0x104(%rbp), %ecx
movl -0xf4(%rbp), %eax
cmpl %ecx, %eax
jne 0x1b1ca
movq -0xd0(%rbp), %rcx
movl 0xa8(%rcx), %edx
movq 0x98(%rcx), %rax
movslq 0xa4(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1b1e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1b1f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1b1bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x31e0
leaq -0xc1(%rbp), %rdi
callq 0x3300
jmp 0x1b1f8
movq -0xd0(%rbp), %rax
movq 0x98(%rax), %rcx
movslq 0xa4(%rax), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0xac(%rax)
jmp 0x1b1ea
leaq -0x88(%rbp), %rdi
callq 0x62f0
jmp 0x1b206
leaq -0x88(%rbp), %rdi
callq 0x62f0
jmp 0x1b20f
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3480
nopl (%rax,%rax)
// File: ys1998[P]spsim/src/mem.cpp
// Function: MEM::tock()
void MEM::tock(){
	if(i.is_valid()){
		if(out->valid()){
			read = false;	// previous data has not been read; stall
		}else{
			read = true;
			out->write(std::make_tuple(i,res));
			Instruction reset; i = reset;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
addq $0x8, %rdi
callq 0x6280
testb $0x1, %al
jne 0x1b24c
jmp 0x1b352
movq -0x118(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x6420
testb $0x1, %al
jne 0x1b265
jmp 0x1b278
movq -0x118(%rbp), %rax
movb $0x0, 0xb0(%rax)
jmp 0x1b350
movq -0x118(%rbp), %rdx
movb $0x1, 0xb0(%rdx)
movq 0x88(%rdx), %rax
movq %rax, -0x128(%rbp)
movq %rdx, %rsi
addq $0x8, %rsi
addq $0xac, %rdx
leaq -0x88(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x6470
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
callq 0x6440
jmp 0x1b2ca
leaq -0x88(%rbp), %rdi
callq 0x64b0
leaq -0x110(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0xe8a0
movq -0x118(%rbp), %rdi
movq -0x130(%rbp), %rsi
addq $0x8, %rdi
callq 0x6380
jmp 0x1b302
leaq -0x110(%rbp), %rdi
callq 0x61d0
jmp 0x1b350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x64b0
jmp 0x1b35b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x61d0
jmp 0x1b35b
jmp 0x1b352
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3480
nopw (%rax,%rax)
// File: ys1998[P]spsim/src/queues.cpp
// Function: IntegerQueue::add(Instruction)
int IntegerQueue::add(Instruction instr){
	if(_q.size() < INSTR_QUEUE_SIZE){
		_q.push_back(instr);
		return 0;
	}else{
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xac70
cmpq $0x10, %rax
jae 0x1b3dd
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xab70
movl $0x0, -0x4(%rbp)
jmp 0x1b3e4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ys1998[P]spsim/src/queues.cpp
// Function: IntegerQueue::flush(int)
void IntegerQueue::flush(int id){
	size_t i=0;
	while(i < _q.size()){
		if(_q[i].get_id() > id){
			_q.erase(_q.begin() + i);
		}else{
			i++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0x18(%rbp)
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0xac70
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x1c650
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaca0
movq %rax, %rdi
callq 0x6270
cmpl -0xc(%rbp), %eax
jle 0x1c63f
movq -0xa0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xad70
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xad30
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xada0
movq -0xa0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0xacd0
jmp 0x1c64b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c5b5
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: ys1998[P]spsim/src/queues.cpp
// Function: AddressQueue::add(Instruction)
int AddressQueue::add(Instruction instr){
	if(_q.size() < ADDR_QUEUE_SIZE){
		_q.push_back(instr);
		_addr.push_back(-2);
		return 0;
	}else{
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xac70
cmpq $0x10, %rax
jae 0x1c735
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xab70
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
movl $0xfffffffe, -0x1c(%rbp) # imm = 0xFFFFFFFE
leaq -0x1c(%rbp), %rsi
callq 0x1d910
movl $0x0, -0x4(%rbp)
jmp 0x1c73c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ys1998[P]spsim/src/queues.cpp
// Function: AddressQueue::findswaddr(int)
bool AddressQueue::findswaddr(int index){
	int myaddr = _addr[index];
	for(size_t i=0; i < _q.size() && i < (unsigned int)index; ++i){
		if ((myaddr == _addr[i] && ((std::get<0>(_q[i].type()))) == OPCODE["sw"])){
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x58, %rdi
movslq -0x14(%rbp), %rsi
callq 0x12560
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0xac70
movq -0x78(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x69(%rbp)
jae 0x1d0f6
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
setb %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x1d102
jmp 0x1d256
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x80(%rbp)
addq $0x58, %rdi
movq -0x20(%rbp), %rsi
callq 0x12560
movl -0x80(%rbp), %ecx
movl (%rax), %edx
movb $0x0, -0x4a(%rbp)
movb $0x0, -0x5d(%rbp)
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x79(%rbp)
jne 0x1d1c6
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xaca0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x105b0
movq -0x98(%rbp), %rdi
callq 0x6210
movl (%rax), %eax
movl %eax, -0x8c(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3490
movq -0x88(%rbp), %rdx
movb $0x1, -0x4a(%rbp)
leaq 0x4e94(%rip), %rsi      # 0x2201d
leaq -0x48(%rbp), %rdi
callq 0x6020
jmp 0x1d194
movb $0x1, -0x5d(%rbp)
leaq 0x12129(%rip), %rdi     # 0x2f2c8
leaq -0x48(%rbp), %rsi
callq 0x5f40
movq %rax, -0xa0(%rbp)
jmp 0x1d1b1
movl -0x8c(%rbp), %eax
movq -0xa0(%rbp), %rcx
cmpl (%rcx), %eax
sete %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
movb %al, -0xa1(%rbp)
testb $0x1, -0x5d(%rbp)
jne 0x1d1d7
jmp 0x1d1e0
leaq -0x48(%rbp), %rdi
callq 0x31e0
testb $0x1, -0x4a(%rbp)
jne 0x1d1e8
jmp 0x1d1f1
leaq -0x49(%rbp), %rdi
callq 0x3300
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x1d1fd
jmp 0x1d243
movb $0x0, -0x1(%rbp)
jmp 0x1d25a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1d230
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x5d(%rbp)
jne 0x1d225
jmp 0x1d22e
leaq -0x48(%rbp), %rdi
callq 0x31e0
jmp 0x1d230
testb $0x1, -0x4a(%rbp)
jne 0x1d238
jmp 0x1d241
leaq -0x49(%rbp), %rdi
callq 0x3300
jmp 0x1d268
jmp 0x1d245
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1d0c4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: ys1998[P]spsim/src/queues.cpp
// Function: AddressQueue::ALUissue()
std::tuple<Instruction, int> AddressQueue::ALUissue(){
	for(size_t i=0; i < _q.size(); ++i){
		if (_addr[i]!=-2||_addr[i]==-1)
			continue;
		Instruction temp = _q[i];
		if(temp.is_valid()){
			auto regs = temp.physical_regs();
			if(!*(b + std::get<1>(regs))){
				_addr[i] = -1;
				return std::make_tuple(temp, i);
			}
		}
	}
	return std::make_tuple(Instruction(), -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x1c0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x1d8(%rbp)
callq 0xac70
movq %rax, %rcx
movq -0x1d8(%rbp), %rax
cmpq %rcx, %rax
jae 0x1d725
movq -0x1c0(%rbp), %rdi
addq $0x58, %rdi
movq -0x18(%rbp), %rsi
callq 0x12560
cmpl $-0x2, (%rax)
jne 0x1d5d3
movq -0x1c0(%rbp), %rdi
addq $0x58, %rdi
movq -0x18(%rbp), %rsi
callq 0x12560
cmpl $-0x1, (%rax)
jne 0x1d5d8
jmp 0x1d714
movq -0x1c0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaca0
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x6c70
movq -0x1e8(%rbp), %rdi
callq 0x6280
movb %al, -0x1d9(%rbp)
jmp 0x1d612
movb -0x1d9(%rbp), %al
testb $0x1, %al
jne 0x1d621
jmp 0x1d6ee
leaq -0xac(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x10520
jmp 0x1d636
movq -0x1c0(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x1f0(%rbp)
leaq -0xac(%rbp), %rdi
callq 0x10ad0
movq %rax, %rcx
movq -0x1f0(%rbp), %rax
movslq (%rcx), %rcx
testb $0x1, (%rax,%rcx)
jne 0x1d6ec
movq -0x1c0(%rbp), %rdi
addq $0x58, %rdi
movq -0x18(%rbp), %rsi
callq 0x12560
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
leaq -0x130(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x1dad0
jmp 0x1d69e
movq -0x1d0(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x1db10
leaq -0x130(%rbp), %rdi
callq 0x1db40
movl $0x1, -0x134(%rbp)
jmp 0x1d6f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x61d0
jmp 0x1d79c
jmp 0x1d6ee
movl $0x0, -0x134(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x61d0
movl -0x134(%rbp), %eax
testl %eax, %eax
je 0x1d712
jmp 0x1d710
jmp 0x1d78c
jmp 0x1d714
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1d577
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0xe8a0
movq -0x1d0(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
movl $0xffffffff, -0x1b4(%rbp) # imm = 0xFFFFFFFF
leaq -0x1b4(%rbp), %rdx
callq 0x1db60
jmp 0x1d75e
leaq -0x1b0(%rbp), %rdi
callq 0x61d0
jmp 0x1d78c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x61d0
jmp 0x1d79c
movq -0x1c8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3480
nopl (%rax,%rax)
// File: ys1998[P]spsim/src/queues.cpp
// Function: AddressQueue::flush(int)
void AddressQueue::flush(int id){
	size_t i=0;
	while(i < _q.size()){
		if(_q[i].get_id() > id){
			_q.erase(_q.begin() + i);
			_addr.erase(_addr.begin() + i);
		}else{
			i++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x128(%rbp)
callq 0xac70
movq %rax, %rcx
movq -0x128(%rbp), %rax
cmpq %rcx, %rax
jae 0x1d8e1
movq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaca0
movq %rax, %rdi
callq 0x6270
cmpl -0xc(%rbp), %eax
jle 0x1d8d0
movq -0x120(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xad70
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xad30
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xada0
movq -0x120(%rbp), %rsi
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0xacd0
movq -0x120(%rbp), %rsi
movq %rsi, %rax
addq $0x58, %rax
movq %rax, -0x130(%rbp)
addq $0x58, %rsi
leaq -0xf8(%rbp), %rdi
callq 0x1a050
movq -0x18(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x12920
leaq -0xb8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1d9a0
movq -0x130(%rbp), %rsi
leaq -0x118(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x1d940
jmp 0x1d8dc
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1d7d5
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw (%rax,%rax)
// File: eugene87222[P]Game-of-Life/gol.cpp
// Function: randomBoard(int, int)
void randomBoard(int height, int width) {
    emptyBoard(height, width);
    srand(time(NULL));
    for(int i=1; i<height+1; i++) {
        for(int j=1; j<width+1; j++) {
            int score = rand()%100 + 1;
            // 0 for dead
            // 1 for alive
            if(score >= 50) board[i][j] = 0;
            else board[i][j] = 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x24a0
xorl %eax, %eax
movl %eax, %edi
callq 0x2160
movl %eax, %edi
callq 0x2170
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2661
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2651
callq 0x2040
movl $0x64, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
cmpl $0x32, -0x14(%rbp)
jl 0x2622
movslq -0xc(%rbp), %rsi
leaq 0xbb77(%rip), %rdi      # 0xe180
callq 0x4270
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x4290
movl $0x0, (%rax)
jmp 0x2644
movslq -0xc(%rbp), %rsi
leaq 0xbb53(%rip), %rdi      # 0xe180
callq 0x4270
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x4290
movl $0x1, (%rax)
jmp 0x2646
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x25d8
jmp 0x2653
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x25c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4440
xorb $-0x1, %al
testb $0x1, %al
jne 0x23f5
jmp 0x23f7
jmp 0x2416
leaq 0xac52(%rip), %rdi      # 0xd050
leaq 0xac54(%rip), %rsi      # 0xd059
movl $0x5d, %edx
leaq 0xac55(%rip), %rcx      # 0xd066
callq 0x20e0
movq -0x28(%rbp), %rdi
callq 0x4460
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4490
movq %rax, %rdi
callq 0x20a0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0xac48(%rip), %rsi      # 0xd092
movb $0x0, %al
callq 0x2200
leaq -0x18(%rbp), %rdi
callq 0x44f0
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x4520
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x44c0
testb $0x1, %al
jne 0x247e
jmp 0x24ae
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4490
movq %rax, %rdi
callq 0x20a0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0xabec(%rip), %rsi      # 0xd091
movb $0x0, %al
callq 0x2200
jmp 0x2451
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4550
testb $0x1, %al
jne 0x256d
movq -0x28(%rbp), %rdi
callq 0x4590
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x45c0
movq -0x30(%rbp), %rdi
movl (%rax), %edx
leaq 0xab86(%rip), %rsi      # 0xd096
movb $0x0, %al
callq 0x2200
leaq -0x18(%rbp), %rdi
callq 0x4620
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x4640
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x45e0
testb $0x1, %al
jne 0x2544
jmp 0x256b
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x45c0
movq -0x40(%rbp), %rdi
movl (%rax), %edx
leaq 0xab33(%rip), %rsi      # 0xd095
movb $0x0, %al
callq 0x2200
jmp 0x2517
jmp 0x256d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x11(%rbp), %edi
callq 0x2250
cmpl $0x0, %eax
jne 0x25ae
movb $0x0, -0x1(%rbp)
jmp 0x25e8
movsbl -0x11(%rbp), %edi
callq 0x2600
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x18(%rbp)
movl (%rax), %eax
andl -0x18(%rbp), %eax
cmpl $0x0, %eax
je 0x25d0
movb $0x0, -0x1(%rbp)
jmp 0x25e8
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
orl (%rax), %ecx
movl %ecx, (%rax)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21c0
movq -0x10(%rbp), %rdi
callq 0x2070
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x288d
movq -0x18(%rbp), %rdi
callq 0x2280
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x28b7
cmpl $0xa, -0x1c(%rbp)
jne 0x2899
movb $0x1, -0x1(%rbp)
jmp 0x28b7
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
callq 0x22a0
movq -0x28(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
jmp 0x2869
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x5930
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x291e
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
leaq -0x1c(%rbp), %rdi
movsbl (%rax), %esi
callq 0x2580
testb $0x1, %al
jne 0x291c
movl $0x0, -0x4(%rbp)
jmp 0x292d
jmp 0x28e8
movl -0x14(%rbp), %esi
leaq -0x1c(%rbp), %rdi
callq 0x5950
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4b90
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4bb0
movl %eax, %ecx
movq -0x50(%rbp), %rax
addl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jne 0x29d6
jmp 0x29f5
leaq 0xa6bc(%rip), %rdi      # 0xd099
leaq 0xa675(%rip), %rsi      # 0xd059
movl $0x14e, %edx            # imm = 0x14E
leaq 0xa6cf(%rip), %rcx      # 0xd0bf
callq 0x20e0
movq -0x18(%rbp), %rdi
callq 0x4550
xorb $-0x1, %al
testb $0x1, %al
jne 0x2a06
jmp 0x2a08
jmp 0x2a27
leaq 0xa6fb(%rip), %rdi      # 0xd10a
leaq 0xa643(%rip), %rsi      # 0xd059
movl $0x14f, %edx            # imm = 0x14F
leaq 0xa69d(%rip), %rcx      # 0xd0bf
callq 0x20e0
movq -0x58(%rbp), %rdi
callq 0x4bd0
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rdi
callq 0x4c40
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4c00
testb $0x1, %al
jne 0x2a54
jmp 0x2a70
leaq -0x28(%rbp), %rdi
callq 0x4c70
movq %rax, %rdi
callq 0x4c90
leaq -0x28(%rbp), %rdi
callq 0x4cc0
jmp 0x2a34
movq -0x18(%rbp), %rdi
callq 0x4590
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x45c0
movl (%rax), %edi
movl -0x1c(%rbp), %esi
callq 0x2b40
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4bb0
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
ja 0x2aad
jmp 0x2acc
leaq 0xa662(%rip), %rdi      # 0xd116
leaq 0xa59e(%rip), %rsi      # 0xd059
movl $0x156, %edx            # imm = 0x156
leaq 0xa5f8(%rip), %rcx      # 0xd0bf
callq 0x20e0
movq -0x58(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x4ce0
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x45c0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl (%rax), %edx
callq 0x2940
leaq -0x38(%rbp), %rdi
callq 0x4620
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4640
movq -0x78(%rbp), %rdi
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x45e0
testb $0x1, %al
jne 0x2a7d
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq $0x0, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
callq 0x4d00
movq %rax, -0x28(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4d70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4d30
testb $0x1, %al
jne 0x2bd9
jmp 0x2c22
leaq -0x28(%rbp), %rdi
callq 0x4da0
movq %rax, %rdi
callq 0x4dc0
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4da0
movq %rax, %rdi
callq 0x4de0
movq %rax, %rdi
callq 0x4df0
cmpq $0x1, %rax
jbe 0x2c15
movb $0x0, -0x19(%rbp)
jmp 0x2c17
leaq -0x28(%rbp), %rdi
callq 0x4e10
jmp 0x2bb9
testb $0x1, -0x19(%rbp)
je 0x2c37
callq 0x4e30
movsd %xmm0, -0x8(%rbp)
jmp 0x2d53
movq -0x60(%rbp), %rdi
movq $0x0, -0x38(%rbp)
movaps 0xa3c6(%rip), %xmm1     # 0xd010
movq -0x18(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xa3c5(%rip), %xmm1     # 0xd020
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x4d00
movq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4d70
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4d30
testb $0x1, %al
jne 0x2c9b
jmp 0x2d32
leaq -0x48(%rbp), %rdi
callq 0x4da0
movq %rax, %rdi
callq 0x4dc0
cmpq $0x0, %rax
jbe 0x2d22
leaq -0x48(%rbp), %rdi
callq 0x4da0
movq %rax, %rdi
callq 0x4dc0
movq %rax, %xmm0
movaps 0xa341(%rip), %xmm1     # 0xd010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xa345(%rip), %xmm1     # 0xd020
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x58(%rbp), %xmm0
callq 0x2110
movaps %xmm0, %xmm2
movsd -0x68(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x2d24
leaq -0x48(%rbp), %rdi
callq 0x4e10
jmp 0x2c78
movsd -0x38(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x24c0
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xa099(%rip), %rdi      # 0xd1f9
callq 0x2180
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x4f20
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x4e30
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x31ae
jp 0x31ae
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xa056(%rip), %rdi      # 0xd1fd
callq 0x2180
jmp 0x31c9
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movsd -0x20(%rbp), %xmm0
leaq 0xa03f(%rip), %rsi      # 0xd201
movb $0x1, %al
callq 0x2200
movq -0x28(%rbp), %rdi
callq 0x4d00
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4da0
movq %rax, %rdi
callq 0x4dc0
movq -0x50(%rbp), %rdi
movl %eax, %edx
leaq 0x9e93(%rip), %rsi      # 0xd096
movb $0x0, %al
callq 0x2200
leaq -0x30(%rbp), %rdi
callq 0x4e10
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4d70
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x4d30
testb $0x1, %al
jne 0x3237
jmp 0x326a
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4da0
movq %rax, %rdi
callq 0x4dc0
movq -0x60(%rbp), %rdi
movl %eax, %edx
leaq 0x9fa6(%rip), %rsi      # 0xd207
movb $0x0, %al
callq 0x2200
jmp 0x320a
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0xa, %edi
callq 0x22c0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x24c0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x9f44(%rip), %rdi      # 0xd20b
callq 0x2180
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x4f20
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x9f20(%rip), %rdi      # 0xd20f
callq 0x2180
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x21d0
movq -0x10(%rbp), %rdi
callq 0x4590
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4640
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x45e0
testb $0x1, %al
jne 0x3434
jmp 0x3471
leaq -0x40(%rbp), %rdi
callq 0x45c0
movl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x3520
jmp 0x344a
jmp 0x344c
leaq -0x40(%rbp), %rdi
callq 0x4620
jmp 0x3414
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20d0
jmp 0x3513
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
leaq -0x38(%rbp), %rsi
callq 0x5090
movq %rax, -0x78(%rbp)
jmp 0x3488
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x8, %rdi
callq 0x50c0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5060
testb $0x1, %al
jne 0x34b4
jmp 0x34b6
jmp 0x34d5
leaq 0x9d56(%rip), %rdi      # 0xd213
leaq 0x9b95(%rip), %rsi      # 0xd059
movl $0x207, %edx            # imm = 0x207
leaq 0x9d60(%rip), %rcx      # 0xd230
callq 0x20e0
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x84(%rbp)
addq $0x8, %rdi
leaq -0x38(%rbp), %rsi
callq 0x50f0
movq %rax, -0x80(%rbp)
jmp 0x34f5
movq -0x80(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x20d0
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2290
nopl (%rax)
// File: mitchblank[P]qiksolve/qiksolve.cpp
// Function: parse_move(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int*, unsigned int*)
static bool parse_move(string const &cmd, unsigned const word_length, Word * const wordp, unsigned * const matchedp)
{
	WordParser parser;

	char const *p = cmd.c_str();
	for (;;) {
		if (*p == '\0')
			return false;
		if (*p == ' ' || *p == '\t')
			break;
		if (!parser.parse(*p++))
			return false;
	}
	*wordp = parser.result(word_length);
	if (*wordp == 0)
		return false;
	while (*p == ' ' || *p == '\t')
		p++;
	if (!isdigit(*p))
		return false;
	*matchedp = static_cast<unsigned>(atoi(p));
	return *matchedp <= word_length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5930
movq -0x10(%rbp), %rdi
callq 0x20a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4062
movb $0x0, -0x1(%rbp)
jmp 0x413c
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x407a
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x407c
jmp 0x40a6
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movsbl (%rax), %esi
callq 0x2580
testb $0x1, %al
jne 0x40a4
movb $0x0, -0x1(%rbp)
jmp 0x413c
jmp 0x404d
movl -0x14(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x5950
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x40c9
movb $0x0, -0x1(%rbp)
jmp 0x413c
jmp 0x40cb
movq -0x38(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x39(%rbp)
je 0x40ec
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x40f5
jmp 0x4103
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x40cb
movq -0x38(%rbp), %rax
movsbl (%rax), %edi
callq 0x2140
cmpl $0x0, %eax
jne 0x411a
movb $0x0, -0x1(%rbp)
jmp 0x413c
movq -0x38(%rbp), %rdi
callq 0x2230
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
setbe %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kdungs[P]codecon/src/palindronum.cc
// Function: isPalindrome(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto isPalindrome(const std::string& str) noexcept -> bool {
  auto l = std::begin(str);
  auto r = std::end(str);
  --r;

  while (std::distance(l, r) > 0u) {
    if (*l != *r) {
      return false;
    }
    ++l;
    --r;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1620
movq %rax, -0x38(%rbp)
jmp 0x129b
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1660
movq %rax, -0x40(%rbp)
jmp 0x12b2
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1690
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x16b0
movq %rax, -0x48(%rbp)
jmp 0x12e6
movq -0x48(%rbp), %rax
cmpq $0x0, %rax
jle 0x132f
leaq -0x18(%rbp), %rdi
callq 0x16f0
movsbl (%rax), %eax
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x16f0
movq %rax, %rcx
movl -0x4c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x131b
movb $0x0, -0x1(%rbp)
jmp 0x1333
leaq -0x18(%rbp), %rdi
callq 0x1710
leaq -0x20(%rbp), %rdi
callq 0x1690
jmp 0x12c3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1650
nopw %cs:(%rax,%rax)
// File: kdungs[P]codecon/src/palindronum.cc
// Function: stepsToPalindrome(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto stepsToPalindrome(const std::string& str) -> std::size_t {
  for (auto r = std::end(str); r > std::begin(str); --r) {
    auto pal = std::string{};
    pal.reserve(str.size() * 2);
    std::copy(r, std::end(str), std::back_inserter(pal));
    std::reverse(std::begin(pal), std::end(pal));
    std::copy(std::begin(str), std::end(str), std::back_inserter(pal));
    if (isPalindrome(pal)) {
      return pal.size();
    }
  }
  return 0u;  // should never happen!
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1660
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1620
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1730
testb $0x1, %al
jne 0x138f
jmp 0x156d
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x1080
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
addq %rsi, %rsi
callq 0x1110
jmp 0x13bc
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1660
movq %rax, -0xb8(%rbp)
jmp 0x13d6
movq -0xb8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x17e0
movq %rax, -0xc0(%rbp)
jmp 0x13f3
movq -0xc0(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x1770
movq %rax, -0xc8(%rbp)
jmp 0x1418
movq -0xc8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1850
movq %rax, -0xd0(%rbp)
jmp 0x1435
movq -0xd0(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1880
movq %rax, -0xd8(%rbp)
jmp 0x1452
movq -0xd8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x1810
jmp 0x146c
movq -0x10(%rbp), %rdi
callq 0x1620
movq %rax, -0xe0(%rbp)
jmp 0x147e
movq -0xe0(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1660
movq %rax, -0xe8(%rbp)
jmp 0x149e
movq -0xe8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x17e0
movq %rax, -0xf0(%rbp)
jmp 0x14be
movq -0xf0(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x1770
movq %rax, -0xf8(%rbp)
jmp 0x14ef
movq -0xf8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1280
testb $0x1, %al
jne 0x150c
jmp 0x153c
leaq -0x40(%rbp), %rdi
callq 0x1080
movq %rax, -0x8(%rbp)
movl $0x1, -0xa4(%rbp)
jmp 0x1546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1070
jmp 0x1582
movl $0x0, -0xa4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1070
movl -0xa4(%rbp), %eax
testl %eax, %eax
je 0x155d
jmp 0x155b
jmp 0x1575
jmp 0x155f
leaq -0x18(%rbp), %rdi
callq 0x1690
jmp 0x136c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x1120
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xb7c4(%rip), %rdi      # 0x10004
callq 0x43a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x485d
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
jmp 0x486d
leaq 0xb7af(%rip), %rax      # 0x10013
movq %rax, -0xb0(%rbp)
jmp 0x486d
movq -0xb0(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq 0xb79e(%rip), %rdi      # 0x10020
callq 0x43a0
movq -0xc0(%rbp), %rsi
testq %rax, %rax
setne %al
movzbl %al, %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4a20
movq -0xb8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movl $0xf4240, %edx          # imm = 0xF4240
callq 0x4a90
jmp 0x48be
leaq -0xa8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xac40
jmp 0x48d0
leaq -0xa8(%rbp), %rdi
callq 0xaec0
movb %al, -0xc1(%rbp)
jmp 0x48e4
movb -0xc1(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xadf0
leaq -0x78(%rbp), %rdi
callq 0x4c00
leaq -0x50(%rbp), %rdi
callq 0x4ca0
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x496a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x4961
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xadf0
leaq -0x78(%rbp), %rdi
callq 0x4c00
leaq -0x50(%rbp), %rdi
callq 0x4ca0
movq -0x80(%rbp), %rdi
callq 0x44c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b70
jmp 0x499f
jmp 0x49e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40d0
movq 0x1462b(%rip), %rdi     # 0x18fe8
leaq 0xb68e(%rip), %rsi      # 0x10052
callq 0x42d0
movq %rax, -0x28(%rbp)
jmp 0x49cf
movq -0x28(%rbp), %rdi
movq 0x145ce(%rip), %rsi     # 0x18fa8
callq 0x4300
jmp 0x49e1
callq 0x4470
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4470
jmp 0x4a01
jmp 0x4a03
movq -0x18(%rbp), %rdi
callq 0x44c0
movq %rax, %rdi
callq 0x5710
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x4cc0
movq -0x38(%rbp), %rax
leaq 0x13b25(%rip), %rcx     # 0x185e0
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0xb0, %edi
callq 0x42e0
movq %rax, -0x30(%rbp)
jmp 0x4ad6
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4ce0
jmp 0x4ae4
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x10, %edi
callq 0x42e0
movq %rax, -0x40(%rbp)
jmp 0x4b00
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
callq 0x4d40
jmp 0x4b17
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, %rdi
addq $0x20, %rdi
movq 0x18(%rax), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x1b9(%rip), %rdx      # 0x4980
callq 0x44f0
cmpl $0x0, %eax
je 0x4bdf
movl $0x10, %edi
callq 0x4110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0xb4d0(%rip), %rsi      # 0x10032
callq 0x40c0
jmp 0x4b69
movq -0x48(%rbp), %rdi
movq 0x1447c(%rip), %rsi     # 0x18ff0
movq 0x1443d(%rip), %rdx     # 0x18fb8
callq 0x4490
jmp 0x4bf7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4be5
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xb0, %esi
callq 0x42f0
jmp 0x4be5
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x42f0
jmp 0x4be5
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x41e0
jmp 0x4be5
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5190
movq -0x20(%rbp), %rdi
callq 0x44c0
nopw (%rax,%rax)
// File: dustin[P]kvtest/./async.hh
// Function: kvtest::QueuedKVStore::~QueuedKVStore()
~QueuedKVStore() {
            executor->stop();
            pthread_join(thread, NULL);
            delete executor;
            delete iq;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x139c5(%rip), %rcx     # 0x185e0
movq %rcx, (%rax)
movq 0x18(%rax), %rdi
callq 0x79b0
jmp 0x4c29
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4280
jmp 0x4c3c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4c5c
movq -0x18(%rbp), %rdi
movl $0x10, %esi
callq 0x42f0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4c85
movq -0x20(%rbp), %rdi
callq 0x7a20
movq -0x20(%rbp), %rdi
movl $0xb0, %esi
callq 0x42f0
movq -0x10(%rbp), %rdi
callq 0x5190
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5710
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x51f0
leaq -0xc0(%rbp), %rdi
callq 0x6ca0
jmp 0x4dd1
movq -0xd8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xe8(%rbp)
movl $0x10, %edi
callq 0x42e0
movq %rax, -0xe0(%rbp)
jmp 0x4df6
movq -0xe0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x6ea0
jmp 0x4e0b
movq -0xe0(%rbp), %rsi
movq -0xe8(%rbp), %rdi
callq 0x6dd0
jmp 0x4e20
leaq -0xc0(%rbp), %rdi
callq 0x6ee0
jmp 0x4e2e
leaq -0xc0(%rbp), %rdi
callq 0x6fe0
leaq -0x58(%rbp), %rdi
callq 0x5fa0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x4ea3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x4e97
movq -0xe0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
movl $0x10, %esi
callq 0x42f0
leaq -0xc0(%rbp), %rdi
callq 0x6fe0
leaq -0x58(%rbp), %rdi
callq 0x5fa0
movq -0xc8(%rbp), %rdi
callq 0x44c0
nopl (%rax,%rax)