LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ys1998[P]spsim/src/alu.cpp
// Function: ALU3::tick()
void ALU3::tick(void){
	if(in->valid() && read){
		auto inp = in->read();
		in->write(inp);
		i = std::get<0>(inp);
		if(i.is_valid())
			read = false;
		in1 = std::get<1>(inp);
		in2 = std::get<2>(inp);
		i.EXEC = CLOCK;
		i.RF2 = CLOCK + 1;
		if(i.is_valid() && latencies[std::get<1>(i.type())] == 1){
			res = in1 + in2;
			in->read();
		}
		else{
			stall_cycles = latencies[std::get<1>(i.type())] - 1;	
		}
	} 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq 0xc8(%rdi), %r14
cmpb $0x1, 0x80(%r14)
jne 0x4e6e
movq %rdi, %rbx
cmpb $0x1, 0xc0(%rdi)
jne 0x4e6e
movb $0x0, 0x80(%r14)
movq (%r14), %rax
leaq 0x18(%rsp), %r15
movq %rax, -0x8(%r15)
leaq 0x8(%r14), %rsi
movl $0xa, %ecx
movq %r15, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x68(%rsp), %r12
leaq 0x78(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x58(%r14), %rsi
movq 0x60(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x5274
movq 0x78(%r14), %rax
movq %rax, 0x10(%r13)
movq 0xc8(%rbx), %r14
movb $0x1, 0x80(%r14)
leaq 0x8(%r14), %rdi
movl $0xa, %ecx
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x58(%r14), %rdi
movq %r12, %rsi
callq 0x3140
movq 0x88(%rsp), %rax
movq %rax, 0x78(%r14)
movq 0x10(%rsp), %rax
movq %rax, (%r14)
leaq 0x8(%rbx), %r14
movl $0xa, %ecx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x58(%rbx), %rdi
movq %r12, %rsi
callq 0x3140
movq 0x88(%rsp), %rax
movq %rax, 0x78(%rbx)
cmpl $-0x1, 0xc(%rbx)
setne %cl
cmpl $-0x1, 0x8(%rbx)
setne %al
andb %cl, %al
cmpb $0x1, %al
jne 0x4d52
movb $0x0, 0xc0(%rbx)
movq 0x10(%rsp), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0xb4(%rbx)
leaq 0x17498(%rip), %rcx     # 0x1c204
movl (%rcx), %ecx
movl %ecx, 0x48(%rbx)
incl %ecx
movl %ecx, 0x4c(%rbx)
testb %al, %al
je 0x4e2f
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xa8b8
leaq 0x80(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x51b2
cmpl $0x1, (%rax)
jne 0x4e2f
movl 0xb8(%rbx), %eax
addl 0xb4(%rbx), %eax
movl %eax, 0xbc(%rbx)
movq 0xc8(%rbx), %rbx
movb $0x0, 0x80(%rbx)
movq (%rbx), %rax
leaq 0x98(%rsp), %rdi
movq %rax, -0x8(%rdi)
leaq 0x8(%rbx), %rsi
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
leaq 0xe8(%rsp), %rdi
leaq 0xf8(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x58(%rbx), %rsi
movq 0x60(%rbx), %rdx
addq %rsi, %rdx
callq 0x5274
movq 0x78(%rbx), %rax
movq %rax, 0x108(%rsp)
movq 0xe8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4e57
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0x4e57
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xa8b8
leaq 0x80(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x51b2
movl (%rax), %eax
decl %eax
movl %eax, 0xb0(%rbx)
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x4e6e
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3200
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4e83
jmp 0x4e83
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x4e9d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x3340
nop
// File: /workspace/github_cpp_makefile_star2_O3/ys1998[P]spsim/src/alu.cpp
// Function: ALU3::flush(int)
void ALU3::flush(int id){
	if(i.get_id() > id){
		Instruction reset;
		i = reset;
		stall_cycles = 0;
		read = true;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
cmpl %esi, 0x8(%rdi)
jle 0x509d
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7a5a
movl $0xa, %ecx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x58(%rbx), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3140
leaq 0x68(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x78(%rbx)
movl $0x0, 0xb0(%rbx)
movb $0x1, 0xc0(%rbx)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x509d
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3200
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50c8
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x3340
// File: /workspace/github_cpp_makefile_star2_O3/ys1998[P]spsim/src/decoder.cpp
// Function: Decoder::Decoder(std::deque<Instruction, std::allocator<Instruction>>*, FreeList*, ActiveList*, int*, bool*, IntegerQueue*, AddressQueue*, int*, int*, Fetcher*)
Decoder::Decoder(Buffer<Instruction>* d, FreeList *f, ActiveList *a, int *r, 
				bool *b, IntegerQueue *iq, AddressQueue *aq, int *p, int *pa,
				Fetcher *ft){
	this->d = d; this->f = f; this->a = a;
	this->r = r; this->b = b; this->iq = iq;
	this->aq = aq; this->predict = p; this->predict_addr = pa;
	this->ft = ft;
	decode_signal = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x162c4(%rip), %rax     # 0x1bc80
movq %rax, (%rdi)
addq $0x8, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbp)
movups %xmm0, 0x18(%rbp)
movups %xmm0, 0x28(%rbp)
movups %xmm0, 0x38(%rbp)
movups %xmm0, 0x48(%rbp)
xorl %esi, %esi
callq 0x64a8
movq %r13, 0x58(%rbp)
movq %r12, 0x60(%rbp)
movq %r15, 0x68(%rbp)
movq %r14, 0x70(%rbp)
movq %rbx, 0x78(%rbp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x80(%rbp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, 0x98(%rbp)
movq 0x60(%rsp), %rax
movq %rax, 0xa8(%rbp)
movb $0x1, 0x90(%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ys1998[P]spsim/src/decoder.cpp
// Function: Decoder::flush(int)
void Decoder::flush(int id){
	// clean eveerything, no check needed
	_q.clear();
	d->clear();
	a->flush(id);
	iq->flush(id);
	aq->flush(id);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x6480
movq 0x58(%r14), %rdi
callq 0x6480
movq 0x68(%r14), %rdi
movl %ebx, %esi
callq 0xcc32
movq 0x80(%r14), %rdi
movl %ebx, %esi
callq 0x12c6a
movq 0x88(%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13f48
nop
// File: /workspace/github_cpp_makefile_star2_O3/ys1998[P]spsim/src/fetcher.cpp
// Function: Fetcher::tock()
void Fetcher::tock(void){
	for(int i = 0; i < INSTR_FETCHED_PER_CYCLE; ++i){
		if((unsigned int)_PC < cache->size() && (*cache)[_PC].is_valid() && dest->size() < FETCH_QUEUE_SIZE){
			Instruction temp = (*cache)[_PC++];
			temp.IF = CLOCK;
			dest->push_back(temp);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movb $0x1, %bpl
leaq 0x60(%rsp), %r13
movabsq $-0x1111111111111111, %r14 # imm = 0xEEEEEEEEEEEEEEEF
movq %rsp, %r15
movl 0x8(%rbx), %ecx
movq 0x10(%rbx), %rsi
movq 0x48(%rsi), %rdx
movq 0x28(%rsi), %rax
movq %rdx, %rdi
subq %rax, %rdi
sarq $0x3, %rdi
cmpq $0x1, %rdx
adcq $-0x1, %rdi
movq 0x30(%rsi), %rdx
subq 0x38(%rsi), %rdx
sarq $0x3, %rdx
imulq %r14, %rdx
leaq (%rdx,%rdi,4), %rdx
movq 0x10(%rsi), %r12
movq 0x20(%rsi), %rdi
subq %r12, %rdi
sarq $0x3, %rdi
imulq %r14, %rdi
addq %rdx, %rdi
cmpq %rcx, %rdi
jbe 0x745b
movq %r12, %rdx
subq 0x18(%rsi), %rdx
movslq %ecx, %rsi
sarq $0x3, %rdx
imulq %r14, %rdx
addq %rsi, %rdx
js 0x7336
cmpq $0x3, %rdx
ja 0x733f
imulq $0x78, %rsi, %rdi
addq %r12, %rdi
jmp 0x735c
movq %rdx, %r8
sarq $0x2, %r8
jmp 0x7346
movq %rdx, %r8
shrq $0x2, %r8
leaq (,%r8,4), %rdi
movq %rdx, %r9
subq %rdi, %r9
imulq $0x78, %r9, %rdi
addq (%rax,%r8,8), %rdi
cmpl $-0x1, 0x4(%rdi)
je 0x745b
cmpl $-0x1, (%rdi)
je 0x745b
movq 0x18(%rbx), %rdi
movq 0x48(%rdi), %r8
movq %r8, %r9
subq 0x28(%rdi), %r9
sarq $0x3, %r9
cmpq $0x1, %r8
adcq $-0x1, %r9
movq 0x20(%rdi), %r8
movq 0x30(%rdi), %r10
subq 0x38(%rdi), %r10
sarq $0x3, %r10
imulq %r14, %r10
leaq (%r10,%r9,4), %r9
subq 0x10(%rdi), %r8
sarq $0x3, %r8
imulq %r14, %r8
addq %r9, %r8
cmpq $0x1f, %r8
ja 0x745b
incl %ecx
movl %ecx, 0x8(%rbx)
testq %rdx, %rdx
js 0x73d4
cmpq $0x3, %rdx
ja 0x73dd
imulq $0x78, %rsi, %rax
addq %rax, %r12
jmp 0x73f7
movq %rdx, %rcx
sarq $0x2, %rcx
jmp 0x73e4
movq %rdx, %rcx
shrq $0x2, %rcx
leaq (,%rcx,4), %rsi
subq %rsi, %rdx
imulq $0x78, %rdx, %r12
addq (%rax,%rcx,8), %r12
movl $0xa, %ecx
movq %r15, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r13, 0x50(%rsp)
movq 0x50(%r12), %rsi
movq 0x58(%r12), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x5274
movq 0x70(%r12), %rax
movq %rax, 0x70(%rsp)
leaq 0x14dd2(%rip), %rax     # 0x1c204
movl (%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x63d2
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x745b
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x3200
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x72bc
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x7493
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x3340
nop
// File: /workspace/github_cpp_makefile_star2_O3/ys1998[P]spsim/src/flusher.cpp
// Function: Flusher::flush(int, int)
void Flusher::flush(int id, int PC){
	is->flush(id);
	d->flush(id);
	f->update_PC(PC);
	w->flush(id);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x10(%rax)
movq 0x8(%r14), %rdi
movl %ebx, %esi
callq 0x749c
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O3/ys1998[P]spsim/src/issuer.cpp
// Function: Issuer::attach_latch(int, Latch<std::tuple<Instruction, int, int>>*, int)
void Issuer::attach_latch(int idx, Latch< std::tuple<Instruction, int, int> > *l,int type){
	this->l[idx] = l;
	if(type == 2)
		addrescal_latch =idx;
	if(type == 3)
		memory_latch = idx;
}

// Assembly:
movslq %esi, %rax
movq %rdx, 0x1e8(%rdi,%rax,8)
cmpl $0x3, %ecx
je 0xac6e
cmpl $0x2, %ecx
jne 0xac74
movl %esi, 0x220(%rdi)
retq
movl %esi, 0x224(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ys1998[P]spsim/src/main.cpp
// Function: print_mem(int*)
void print_mem(int *d){
	std::cout << "Memory (D-cache)\n";
	for(int j=0; j<4; ++j){
		std::cout << "\033[0;36m     Index     Value\033[0m";
	}
	std::cout << "\n";
	for(int i=0; i < DCACHE_SIZE/4; ++i){
		for(int j=0; j < 4; ++j){
				std::cout << "\033[1;36m" <<
				std::setfill(' ') << std::setw(10) << j*DCACHE_SIZE/4 + i << "\033[0m" <<
				std::setfill(' ') << std::setw(10) << *(d + j*DCACHE_SIZE/4 + i);
		}
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd681(%rip), %r14      # 0x1bfd8
leaq 0x7a3d(%rip), %rsi      # 0x1639b
movl $0x11, %edx
movq %r14, %rdi
callq 0x3240
movl $0x4, %ebp
leaq 0x7a36(%rip), %r15      # 0x163ad
movl $0x1f, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3240
decl %ebp
jne 0xe977
leaq 0x7a19(%rip), %rsi      # 0x163ab
movl $0x1, %edx
movq %r14, %rdi
callq 0x3240
xorl %r15d, %r15d
xorl %r12d, %r12d
movl $0x7, %edx
movq %r14, %rdi
leaq 0x79df(%rip), %rsi      # 0x16393
callq 0x3240
movq (%r14), %rax
movq -0x18(%rax), %rcx
leaq (%r14,%rcx), %r13
cmpb $0x0, 0xe1(%r14,%rcx)
jne 0xe9e7
movq %r13, %rdi
movl $0x20, %esi
callq 0x31e0
movb $0x1, 0xe1(%r13)
movq (%r14), %rax
movb $0x20, 0xe0(%r13)
movq -0x18(%rax), %rax
movq $0xa, 0x10(%r14,%rax)
leal (%r15,%r12), %esi
movq %r14, %rdi
callq 0x3330
movq %rax, %r13
movl $0x4, %edx
movq %rax, %rdi
leaq 0x7a43(%rip), %rsi      # 0x1645d
callq 0x3240
movq (%r13), %rax
movq -0x18(%rax), %rcx
leaq (%rcx,%r13), %rbp
cmpb $0x0, 0xe1(%r13,%rcx)
jne 0xea4e
movq %rbp, %rdi
movl $0x20, %esi
callq 0x31e0
movb $0x1, 0xe1(%rbp)
movq (%r13), %rax
movb $0x20, 0xe0(%rbp)
movq -0x18(%rax), %rax
movq $0xa, 0x10(%r13,%rax)
movl (%rbx,%r12,4), %esi
movq %r13, %rdi
callq 0x3330
addq $0x19, %r12
cmpq $0x64, %r12
jne 0xe9a5
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
incq %r15
addq $0x4, %rbx
cmpq $0x19, %r15
jne 0xe9a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq 0x80(%rdi), %r14
cmpb $0x1, 0x80(%r14)
jne 0x11e74
movq %rdi, %rbx
cmpb $0x1, 0xb0(%rdi)
jne 0x11e74
movb $0x0, 0x80(%r14)
movq (%r14), %rax
leaq 0x30(%rsp), %r15
movq %rax, -0x8(%r15)
leaq 0x8(%r14), %rsi
movl $0xa, %ecx
movq %r15, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x80(%rsp), %r12
leaq 0x90(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x58(%r14), %rsi
movq 0x60(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x5274
movq 0x78(%r14), %rax
movq %rax, 0x10(%r13)
leaq 0x8(%rbx), %r14
movl $0xa, %ecx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x58(%rbx), %rdi
movq %r12, %rsi
callq 0x3140
movq 0xa0(%rsp), %rax
movq %rax, 0x78(%rbx)
movq 0x28(%rsp), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0xa4(%rbx)
leaq 0xa456(%rip), %rax      # 0x1c204
movl (%rax), %eax
movl %eax, 0x50(%rbx)
cmpl $-0x1, 0xc(%rbx)
je 0x11e57
cmpl $-0x1, 0x8(%rbx)
je 0x11e57
movq %rsp, %rdi
movq %r14, %rsi
callq 0xa8b8
movl 0x4(%rsp), %ebp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4237(%rip), %rsi      # 0x1601d
leaq 0x4232(%rip), %rdx      # 0x1601f
leaq 0x8(%rsp), %rdi
callq 0x530a
leaq 0xa412(%rip), %rdi      # 0x1c210
leaq 0x8(%rsp), %rsi
callq 0x5136
movl (%rax), %r15d
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x11e22
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
cmpl %r15d, %ebp
jne 0x11e40
movl 0xa8(%rbx), %eax
movq 0x98(%rbx), %rcx
movslq 0xa4(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
jmp 0x11e57
movq 0x98(%rbx), %rax
movslq 0xa4(%rbx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xac(%rbx)
movq 0x80(%rsp), %rdi
cmpq %r13, %rdi
je 0x11e74
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x3200
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x11ea9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0x11ea9
jmp 0x11ea6
jmp 0x11ea6
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r13, %rdi
je 0x11ec6
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x3340
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpl $-0x1, 0xc(%rdi)
je 0x12003
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
je 0x12003
movq 0x88(%rbx), %r13
cmpb $0x1, 0x80(%r13)
jne 0x11f13
movb $0x0, 0xb0(%rbx)
jmp 0x12003
leaq 0x8(%rbx), %r14
movb $0x1, %al
movb %al, 0xb0(%rbx)
movl 0xac(%rbx), %eax
leaq 0x10(%rsp), %r15
movl %eax, -0x8(%r15)
movl $0xa, %ecx
movq %r15, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %r12
leaq 0x70(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x58(%rbx), %rsi
movq 0x60(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x5274
movq 0x78(%rbx), %rax
movq %rax, 0x10(%rbp)
movb $0x1, %al
movb %al, 0x80(%r13)
leaq 0x8(%r13), %rdi
movl $0xa, %ecx
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x58(%r13), %rdi
movq %r12, %rsi
callq 0x3140
leaq 0x58(%rbx), %r15
movq 0x80(%rsp), %rax
movq %rax, 0x78(%r13)
movl 0x8(%rsp), %eax
movl %eax, (%r13)
movq 0x60(%rsp), %rdi
cmpq %rbp, %rdi
je 0x11fb8
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x7a5a
movl $0xa, %ecx
movq %r14, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x58(%rsp), %rsi
movq %r15, %rdi
callq 0x3140
leaq 0x68(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x78(%rbx)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12003
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3200
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12047
movq 0x68(%rsp), %rsi
jmp 0x1203f
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %rbp, %rdi
je 0x12047
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x3340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
xorl %r13d, %r13d
movabsq $-0x1111111111111111, %rbp # imm = 0xEEEEEEEEEEEEEEEF
leaq 0x8(%rsp), %r12
imulq $0x78, %r13, %r15
movq 0x48(%r14), %rcx
movq 0x28(%r14), %rax
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq $0x1, %rcx
adcq $-0x1, %rdx
movq 0x30(%r14), %rcx
subq 0x38(%r14), %rcx
sarq $0x3, %rcx
imulq %rbp, %rcx
leaq (%rcx,%rdx,4), %rcx
movq 0x10(%r14), %rdx
movq 0x20(%r14), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
imulq %rbp, %rsi
addq %rcx, %rsi
cmpq %rsi, %r13
jae 0x12d74
movq %rdx, %rcx
subq 0x18(%r14), %rcx
sarq $0x3, %rcx
imulq %rbp, %rcx
addq %r13, %rcx
js 0x12d08
cmpq $0x4, %rcx
jae 0x12d11
cmpl %ebx, (%rdx,%r15)
jle 0x12d6c
addq %r15, %rdx
movq (%rax), %rsi
jmp 0x12d3c
movq %rcx, %rdx
sarq $0x2, %rdx
jmp 0x12d18
movq %rcx, %rdx
shrq $0x2, %rdx
movq (%rax,%rdx,8), %rsi
movl %ecx, %edi
andl $0x3, %edi
imulq $0x78, %rdi, %rdi
cmpl %ebx, (%rsi,%rdi)
jle 0x12d6c
leaq (%rax,%rdx,8), %rax
shlq $0x2, %rdx
subq %rdx, %rcx
imulq $0x78, %rcx, %rdx
addq %rsi, %rdx
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
addq $0x1e0, %rsi            # imm = 0x1E0
movq %rsi, 0x18(%rsp)
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6972
jmp 0x12c93
incq %r13
jmp 0x12c8f
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq %rax, %rcx
subq 0x28(%rdi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
movq 0x30(%rdi), %rax
subq 0x38(%rdi), %rax
movq 0x20(%rdi), %rdx
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rdi # imm = 0xEEEEEEEEEEEEEEEF
imulq %rdi, %rax
leaq (%rax,%rcx,4), %rax
subq 0x10(%rbx), %rdx
sarq $0x3, %rdx
imulq %rdi, %rdx
addq %rax, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0xf, %rdx
ja 0x12e78
movq %rbx, %rdi
callq 0x63d2
addq $0x58, %rbx
leaq 0xc(%rsp), %rsi
movl $0xfffffffe, (%rsi)     # imm = 0xFFFFFFFE
movq %rbx, %rdi
callq 0x1426c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movslq %esi, %rdx
movq 0x68(%rdi), %rdi
movq 0x80(%rbx), %rcx
movq %rdi, %rax
subq 0x70(%rbx), %rax
sarq $0x2, %rax
addq %rdx, %rax
js 0x13827
cmpq $0x7f, %rax
ja 0x13830
leaq (%rdi,%rdx,4), %rax
jmp 0x13849
movq %rax, %rdx
sarq $0x7, %rdx
jmp 0x13837
movq %rax, %rdx
shrq $0x7, %rdx
movq %rdx, %rdi
shlq $0x7, %rdi
subq %rdi, %rax
shlq $0x2, %rax
addq (%rcx,%rdx,8), %rax
movl (%rax), %r9d
movl %esi, %r10d
leaq 0x40(%rsp), %r13
xorl %r11d, %r11d
movabsq $-0x1111111111111111, %r15 # imm = 0xEEEEEEEEEEEEEEEF
xorl %r12d, %r12d
xorl %ebp, %ebp
movl %r9d, 0xc(%rsp)
movq %r10, 0x10(%rsp)
movq 0x48(%rbx), %rcx
movq 0x28(%rbx), %rax
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq $0x1, %rcx
adcq $-0x1, %rdx
movq 0x30(%rbx), %rcx
subq 0x38(%rbx), %rcx
sarq $0x3, %rcx
imulq %r15, %rcx
leaq (%rcx,%rdx,4), %rcx
movq 0x10(%rbx), %rsi
movq 0x20(%rbx), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
addq %rcx, %rdx
cmpq %rdx, %rbp
setae %cl
cmpq %r10, %rbp
setae %r14b
orb %cl, %r14b
jne 0x13a05
movq 0x68(%rbx), %rdi
movq 0x80(%rbx), %rdx
movq %rdi, %rcx
subq 0x70(%rbx), %rcx
sarq $0x2, %rcx
addq %rbp, %rcx
js 0x138f3
cmpq $0x7f, %rcx
ja 0x138fc
addq %r11, %rdi
movq %rdi, %rcx
jmp 0x13915
movq %rcx, %rdi
sarq $0x7, %rdi
jmp 0x13903
movq %rcx, %rdi
shrq $0x7, %rdi
movq %rdi, %r8
shlq $0x7, %r8
subq %r8, %rcx
shlq $0x2, %rcx
addq (%rdx,%rdi,8), %rcx
cmpl (%rcx), %r9d
jne 0x139f5
movq %rsi, %rcx
subq 0x18(%rbx), %rcx
sarq $0x3, %rcx
imulq %r15, %rcx
addq %rbp, %rcx
movq %r11, 0x28(%rsp)
movq %r12, 0x20(%rsp)
movq %rbp, 0x18(%rsp)
js 0x1394f
cmpq $0x3, %rcx
ja 0x13958
movq %r13, %rbp
addq %r12, %rsi
jmp 0x13975
movq %rcx, %rdx
sarq $0x2, %rdx
jmp 0x1395f
movq %rcx, %rdx
shrq $0x2, %rdx
movq %r13, %rbp
leaq (,%rdx,4), %rsi
subq %rsi, %rcx
imulq $0x78, %rcx, %rsi
addq (%rax,%rdx,8), %rsi
leaq 0x50(%rsp), %rdi
callq 0xa8b8
movl 0x54(%rsp), %r13d
movq %rbp, 0x30(%rsp)
leaq 0x30(%rsp), %r12
movq %r12, %rdi
leaq 0x2685(%rip), %rsi      # 0x1601d
leaq 0x2680(%rip), %rdx      # 0x1601f
callq 0x530a
leaq 0x8865(%rip), %rdi      # 0x1c210
movq %r12, %rsi
callq 0x5136
movl (%rax), %eax
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
movq 0x18(%rsp), %rbp
je 0x139d7
movq 0x40(%rsp), %rsi
incq %rsi
movl %eax, %r12d
callq 0x3200
movl %r12d, %eax
cmpl %eax, %r13d
leaq 0x40(%rsp), %r13
movl 0xc(%rsp), %r9d
movq 0x10(%rsp), %r10
movq 0x28(%rsp), %r11
movq 0x20(%rsp), %r12
je 0x13a05
incq %rbp
addq $0x78, %r12
addq $0x4, %r11
jmp 0x13870
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x13a31
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x3340
nop
// File: /workspace/github_cpp_makefile_star2_O3/ys1998[P]spsim/src/queues.cpp
// Function: AddressQueue::no_notcalculated_branch_above(Instruction)
bool AddressQueue::no_notcalculated_branch_above(Instruction i){

	for(Buffer< std::pair<Instruction, bool> >::iterator it = al->_q.begin(); it->first.get_id()!=i.get_id() ; ++it){
			if(std::get<0>(it->first.type())==OPCODE["beq"]||std::get<0>(it->first.type())==OPCODE["bne"])
				if(!it->second){
					return 0;
				}
		}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0xa8(%rdi), %rcx
movq 0x10(%rcx), %r14
movl (%r14), %edx
movb $0x1, %al
movq %rsi, 0x40(%rsp)
cmpl (%rsi), %edx
je 0x13b75
movq 0x20(%rcx), %r13
movq 0x28(%rcx), %r12
movq %rsp, %rbx
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0xa8b8
movl 0x54(%rsp), %ebp
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
leaq 0x2572(%rip), %rsi      # 0x1600c
leaq 0x256e(%rip), %rdx      # 0x1600f
callq 0x530a
leaq 0x8763(%rip), %rdi      # 0x1c210
movq %r15, %rsi
callq 0x5136
movb $0x1, %r15b
cmpl (%rax), %ebp
je 0x13b1e
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0xa8b8
movl 0x4c(%rsp), %r15d
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
leaq 0x252f(%rip), %rsi      # 0x16010
leaq 0x252b(%rip), %rdx      # 0x16013
callq 0x530a
leaq 0x871c(%rip), %rdi      # 0x1c210
movq %rbx, %rsi
callq 0x5136
cmpl (%rax), %r15d
sete %r15b
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x13b1e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3200
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x13b3a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
testb %r15b, %r15b
je 0x13b46
cmpb $0x0, 0x78(%r14)
je 0x13b73
subq $-0x80, %r14
cmpq %r13, %r14
jne 0x13b5f
movq 0x8(%r12), %r14
addq $0x8, %r12
leaq 0x200(%r14), %r13
movl (%r14), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x13a70
movb $0x1, %al
jmp 0x13b75
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x13bab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0x13bab
jmp 0x13ba8
jmp 0x13ba8
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x13bc7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x3340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x58(%rdi), %rax
movq %rax, 0x30(%rsp)
xorl %ebp, %ebp
movabsq $-0x1111111111111111, %r15 # imm = 0xEEEEEEEEEEEEEEEF
leaq 0x38(%rsp), %r12
leaq 0x10(%rsp), %r13
imulq $0x78, %rbp, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%r14), %rcx
movq 0x28(%r14), %rax
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq $0x1, %rcx
adcq $-0x1, %rdx
movq 0x30(%r14), %rcx
subq 0x38(%r14), %rcx
sarq $0x3, %rcx
imulq %r15, %rcx
leaq (%rcx,%rdx,4), %rcx
movq 0x10(%r14), %rdx
movq 0x20(%r14), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
imulq %r15, %rsi
addq %rcx, %rsi
cmpq %rsi, %rbp
jae 0x140e7
movq %rdx, %rcx
subq 0x18(%r14), %rcx
sarq $0x3, %rcx
imulq %r15, %rcx
addq %rbp, %rcx
js 0x14002
cmpq $0x4, %rcx
jae 0x1400b
movq 0x8(%rsp), %rcx
cmpl %ebx, (%rdx,%rcx)
jle 0x140df
addq 0x8(%rsp), %rdx
movq (%rax), %rsi
jmp 0x1403a
movq %rcx, %rdx
sarq $0x2, %rdx
jmp 0x14012
movq %rcx, %rdx
shrq $0x2, %rdx
movq (%rax,%rdx,8), %rsi
movl %ecx, %edi
andl $0x3, %edi
imulq $0x78, %rdi, %rdi
cmpl %ebx, (%rsi,%rdi)
jle 0x140df
leaq (%rax,%rdx,8), %rax
shlq $0x2, %rdx
subq %rdx, %rcx
imulq $0x78, %rcx, %rdx
addq %rsi, %rdx
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
addq $0x1e0, %rsi            # imm = 0x1E0
movq %rsi, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x6972
movq 0x68(%r14), %rdx
movq 0x80(%r14), %rax
movq %rdx, %rcx
subq 0x70(%r14), %rcx
sarq $0x2, %rcx
addq %rbp, %rcx
js 0x1408d
cmpq $0x7f, %rcx
ja 0x14096
leaq (%rdx,%rbp,4), %rcx
movq (%rax), %rdx
jmp 0x140af
movq %rcx, %rsi
sarq $0x7, %rsi
jmp 0x1409d
movq %rcx, %rsi
shrq $0x7, %rsi
leaq (%rax,%rsi,8), %rax
movq (%rax), %rdx
shlq $0x7, %rsi
subq %rsi, %rcx
leaq (%rdx,%rcx,4), %rcx
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
addq $0x200, %rdx            # imm = 0x200
movq %rdx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq %r12, %rdi
movq 0x30(%rsp), %rsi
movq %r13, %rdx
callq 0x14528
jmp 0x13f83
incq %rbp
jmp 0x13f7a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
callq 0x2497
xorl %edi, %edi
callq 0x2150
movl %eax, %edi
callq 0x2160
testl %r14d, %r14d
jle 0x25f5
leal 0x1(%rbx), %r15d
incl %r14d
movl $0x1, %r12d
testl %ebx, %ebx
jle 0x25ed
movl $0x1, %r13d
leaq (%r12,%r12,2), %rbp
callq 0x2040
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
xorl %ecx, %ecx
cmpl $0x31, %eax
setl %cl
movq 0x3bb3(%rip), %rax      # 0x6190
movq (%rax,%rbp,8), %rax
movl %ecx, (%rax,%r13,4)
incq %r13
cmpq %r13, %r15
jne 0x25ae
incq %r12
cmpq %r14, %r12
jne 0x25a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/eugene87222[P]Game-of-Life/gol.cpp
// Function: Gosperglidergun(int, int)
void Gosperglidergun(int height, int width) {
    emptyBoard(height, width);

    board[4][2] = 1;
    board[5][2] = 1;
    board[4][3] = 1;
    board[5][3] = 1;

    board[2][13] = 1;
    board[3][13] = 1;
    board[7][13] = 1;
    board[8][13] = 1;
    board[3][15] = 1;
    board[7][15] = 1;
    board[4][16] = 1;
    board[5][16] = 1;
    board[6][16] = 1;
    board[4][17] = 1;
    board[5][17] = 1;
    board[6][17] = 1;

    board[7][20] = 1;
    board[6][21] = 1;
    board[7][21] = 1;
    board[8][21] = 1;
    board[5][22] = 1;
    board[9][22] = 1;
    board[7][23] = 1;
    board[4][24] = 1;
    board[10][24] = 1;
    board[4][25] = 1;
    board[10][25] = 1;
    board[5][26] = 1;
    board[9][26] = 1;
    board[6][27] = 1;
    board[7][27] = 1;
    board[8][27] = 1;

    board[6][36] = 1;
    board[7][36] = 1;
    board[6][37] = 1;
    board[7][37] = 1;
}

// Assembly:
pushq %rax
callq 0x2497
movq 0x3b7f(%rip), %rdx      # 0x6190
movq 0x60(%rdx), %rcx
movl $0x1, %eax
movl %eax, 0x8(%rcx)
movq 0x78(%rdx), %rsi
movl %eax, 0x8(%rsi)
movl %eax, 0xc(%rcx)
movl %eax, 0xc(%rsi)
movq 0x30(%rdx), %rdi
movl %eax, 0x34(%rdi)
movq 0x48(%rdx), %r8
movl %eax, 0x34(%r8)
movq 0xa8(%rdx), %rdi
movl %eax, 0x34(%rdi)
movq 0xc0(%rdx), %r9
movl %eax, 0x34(%r9)
movl %eax, 0x3c(%r8)
movl %eax, 0x3c(%rdi)
movl %eax, 0x40(%rcx)
movl %eax, 0x40(%rsi)
movq 0x90(%rdx), %r8
movl %eax, 0x40(%r8)
movl %eax, 0x44(%rcx)
movl %eax, 0x44(%rsi)
movl %eax, 0x44(%r8)
movl %eax, 0x50(%rdi)
movl %eax, 0x54(%r8)
movl %eax, 0x54(%rdi)
movl %eax, 0x54(%r9)
movl %eax, 0x58(%rsi)
movq 0xd8(%rdx), %r10
movl %eax, 0x58(%r10)
movl %eax, 0x5c(%rdi)
movl %eax, 0x60(%rcx)
movq 0xf0(%rdx), %rdx
movl %eax, 0x60(%rdx)
movl %eax, 0x64(%rcx)
movl %eax, 0x64(%rdx)
movl %eax, 0x68(%rsi)
movl %eax, 0x68(%r10)
movl %eax, 0x6c(%r8)
movl %eax, 0x6c(%rdi)
movl %eax, 0x6c(%r9)
movl %eax, 0x90(%r8)
movl %eax, 0x90(%rdi)
movl %eax, 0x94(%r8)
movl %eax, 0x94(%rdi)
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2898
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x39c6(%rip), %rax      # 0x6190
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 0x2883
leaq (,%rdi,8), %r8
leaq (%r8,%r8,2), %r8
movq 0x399d(%rip), %rbx      # 0x61a8
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 0x2865
addl $-0x4, %ebp
xorl %r8d, %r8d
cmpl $-0x2, %ebp
jb 0x2870
jmp 0x287b
movl $0x1, %r8d
cmpl $0x3, %ebp
jne 0x287b
movq (%rbx), %rbp
addq %r10, %rbp
movl %r8d, (%rbp,%r13,4)
incq %r13
cmpl %r13d, %r11d
jne 0x282b
incq %rdi
cmpl %edi, %esi
jne 0x27f0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38f8(%rip), %rdi      # 0x61a8
leaq 0x38d9(%rip), %rsi      # 0x6190
callq 0x32ac
testl %r14d, %r14d
jle 0x2969
movq 0x38c4(%rip), %rax      # 0x6190
leaq -0x18(%rax), %rcx
leaq 0x18(%rax), %rdx
leal 0x1(%rbx), %esi
incl %r14d
movl $0x1, %edi
testl %ebx, %ebx
jle 0x295d
leaq (,%rdi,8), %r8
leaq (%r8,%r8,2), %r8
movq (%rcx,%r8), %r9
movq (%rax,%r8), %r10
movq (%rdx,%r8), %r11
addq 0x38a6(%rip), %r8       # 0x61a8
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 0x2942
addl $-0x4, %ebp
xorl %r12d, %r12d
cmpl $-0x2, %ebp
jb 0x294d
jmp 0x2955
movl $0x1, %r12d
cmpl $0x3, %ebp
jne 0x2955
movq (%r8), %r13
movl %r12d, (%r13,%r15,4)
incq %r15
cmpq %r15, %rsi
jne 0x2908
incq %rdi
cmpq %r14, %rdi
jne 0x28df
leaq 0x3820(%rip), %rdi      # 0x6190
leaq 0x3831(%rip), %rsi      # 0x61a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32ac
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24a6
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 0x249d
movq %rax, %r15
leaq 0x3c15(%rip), %r12      # 0x6091
movq 0x20(%r15), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21c0
movq %r15, %rdi
callq 0x2180
movq %rax, %r15
cmpq %r14, %rax
jne 0x247c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ba3(%rip), %rdi      # 0x6050
leaq 0x3ba5(%rip), %rsi      # 0x6059
leaq 0x3bab(%rip), %rcx      # 0x6066
movl $0x5d, %edx
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2521
movq %rsi, %rbx
movq %rdi, %r14
movl (%r12), %edx
leaq 0x3bab(%rip), %rsi      # 0x6096
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21c0
addq $0x4, %r12
cmpq 0x8(%r14), %r12
je 0x2521
leaq 0x3b8f(%rip), %r15      # 0x6095
movl (%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21c0
addq $0x4, %r12
cmpq 0x8(%r14), %r12
jne 0x2506
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2210
testl %eax, %eax
je 0x255e
andb $0x1f, %r14b
decb %r14b
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
movl (%rbx), %ecx
movzbl %r14b, %edx
btl %edx, %ecx
jae 0x2562
xorl %eax, %eax
jmp 0x256b
orl %eax, %ecx
movl %ecx, (%rbx)
incl 0x4(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26cf
testb %al, %al
je 0x2616
movq -0x68(%rbp), %rdi
movl %r15d, %esi
callq 0x2721
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x25dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38c4
movq %rax, %rdi
movq %r13, %rsi
callq 0x431e
jmp 0x25dc
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x2628
callq 0x2140
movq -0x40(%rbp), %rax
movq (%rax), %rsi
testq %rsi, %rsi
movq -0x38(%rbp), %r15
movq -0x48(%rbp), %r12
je 0x2681
movq %r15, %rdi
callq 0x392c
movq 0x18(%rbx), %r14
cmpq %r12, %r14
je 0x2681
leaq 0x20(%r14), %rdx
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x2669
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x2671
movq %r15, %rdi
callq 0x459a
movq %r14, %rdi
callq 0x2180
movq %rax, %r14
cmpq %r12, %rax
jne 0x264d
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2692
movq %rax, %r14
jmp 0x26ae
jmp 0x2699
movq %rax, %r14
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x26ae
callq 0x2140
movq -0x38(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x26bf
callq 0x2140
movq %rbx, %rdi
callq 0x3cfe
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
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 0x271a
cmpl $-0x1, %eax
je 0x2710
movl %eax, %edi
callq 0x2260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2130
jmp 0x26ea
cmpq $0x0, 0x8(%rbx)
setne %al
jmp 0x271c
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2758
incq %r14
movsbl %al, %esi
movq %r15, %rdi
callq 0x252a
testb %al, %al
jne 0x273b
xorl %eax, %eax
jmp 0x2762
xorl %eax, %eax
cmpl %ebx, -0x1c(%rbp)
jne 0x2762
movl -0x20(%rbp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %r15
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x5, %rdx
movl 0x48(%rsi), %esi
incl %esi
cmpq %rsi, %rdx
jne 0x28bb
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0x28da
movq %rdi, %r12
cmpq %rcx, %rax
je 0x2833
movq (%rax), %rdx
cmpq %rdx, 0x8(%rax)
je 0x281f
movq %rdx, 0x8(%rax)
movq 0x8(%r12), %rcx
movq $0x0, 0x18(%rax)
addq $0x20, %rax
cmpq %rcx, %rax
jne 0x280d
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 0x289c
shll $0x5, %edi
addq (%r12), %rdi
movq %r15, %rsi
callq 0x276e
addq $0x4, %r13
cmpq 0x8(%r14), %r13
jne 0x2838
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3873(%rip), %rdi      # 0x6116
leaq 0x37af(%rip), %rsi      # 0x6059
leaq 0x380e(%rip), %rcx      # 0x60bf
movl $0x156, %edx            # imm = 0x156
callq 0x20c0
leaq 0x37d7(%rip), %rdi      # 0x6099
leaq 0x3790(%rip), %rsi      # 0x6059
leaq 0x37ef(%rip), %rcx      # 0x60bf
movl $0x14e, %edx            # imm = 0x14E
callq 0x20c0
leaq 0x3829(%rip), %rdi      # 0x610a
leaq 0x3771(%rip), %rsi      # 0x6059
leaq 0x37d0(%rip), %rcx      # 0x60bf
movl $0x14f, %edx            # imm = 0x14F
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %r14
movq 0x8(%rdi), %rax
movsd 0x36f4(%rip), %xmm0     # 0x6008
cmpq %rax, %r14
je 0x29f2
movq %rdi, %rbx
movb $0x1, %dl
xorl %ecx, %ecx
movq %r14, %rsi
addq 0x18(%rsi), %rcx
movq 0x8(%rsi), %rdi
subq (%rsi), %rdi
cmpq $0x5, %rdi
setb %dil
andb %dil, %dl
addq $0x20, %rsi
cmpq %rax, %rsi
jne 0x2927
testb %dl, %dl
jne 0x29f2
cmpq %rax, %r14
je 0x29e6
movq %rcx, %xmm0
punpckldq 0x36bc(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x36c4(%rip), %xmm0     # 0x6030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, -0x30(%rbp)
xorpd %xmm0, %xmm0
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x29db
movapd %xmm0, -0x20(%rbp)
movq %rcx, %xmm1
punpckldq 0x3684(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x368c(%rip), %xmm1     # 0x6030
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
movq 0x8(%rbx), %rax
addq $0x20, %r14
cmpq %rax, %r14
jne 0x2981
jmp 0x29ea
xorpd %xmm0, %xmm0
xorpd 0x364e(%rip), %xmm0     # 0x6040
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24c6
movq 0x10(%r14), %rsi
leaq 0x357c(%rip), %rdi      # 0x61f9
callq 0x2170
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
movl %r15d, %edx
callq 0x3aae
movsd -0x28(%rbp), %xmm0
ucomisd 0x3369(%rip), %xmm0     # 0x6008
movq 0x10(%r14), %rsi
jne 0x2cb5
jp 0x2cb5
leaq 0x354f(%rip), %rdi      # 0x61fd
callq 0x2170
jmp 0x2cc9
leaq 0x3545(%rip), %rax      # 0x6201
movq %rsi, %rdi
movq %rax, %rsi
movb $0x1, %al
callq 0x21c0
movq (%rbx), %r12
movq 0x10(%r14), %rdi
movl 0x18(%r12), %edx
leaq 0x33ba(%rip), %rsi      # 0x6096
xorl %eax, %eax
callq 0x21c0
addq $0x20, %r12
cmpq 0x8(%rbx), %r12
je 0x2d11
leaq 0x3513(%rip), %r15      # 0x6207
movq 0x10(%r14), %rdi
movl 0x18(%r12), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x21c0
addq $0x20, %r12
cmpq 0x8(%rbx), %r12
jne 0x2cf4
movq 0x10(%r14), %rsi
movl $0xa, %edi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2280
nop