LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ys1998[P]spsim/src/lists.cpp
// Function: ActiveList::flush(int)
void ActiveList::flush(int id){
	size_t i = _q.size() - 1;
	while(i != 0){
		if(_q[i].first.get_id() > id){
			auto regs = _q[i].first.physical_regs();
			auto log_regs = _q[i].first.logical_regs();
			
			if(std::get<2>(regs) >= 0 && std::get<2>(regs) < NUM_PHY_REGS)
				f->add(std::get<2>(regs));
			
			if(std::get<2>(log_regs) != -1)
				*(r + std::get<2>(log_regs)) = std::get<3>(regs);
			if(std::get<2>(regs) != -1)
				*(b + std::get<2>(regs)) = false;
			
			_q.erase(_q.begin() + i);
		}
		i--;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x90b2
movq %rax, %r15
leaq 0x10(%r14), %r12
decq %r15
leaq 0x60(%rsp), %rbp
movq %r15, %r13
subq $0x1, %r15
jb 0x909f
movq %r12, %rdi
movq %r13, %rsi
callq 0x9632
cmpl %ebx, (%rax)
jle 0x8fc6
movq %r12, %rdi
movq %r13, %rsi
callq 0x9632
leaq 0x4(%rsp), %rdi
movq %rax, %rsi
callq 0x7c52
movq %r12, %rdi
movq %r13, %rsi
callq 0x9632
leaq 0x14(%rsp), %rdi
movq %rax, %rsi
callq 0x7c64
movl 0x8(%rsp), %esi
cmpl $0x3f, %esi
ja 0x9024
movq 0x58(%r14), %rdi
callq 0x87da
movslq 0x14(%rsp), %rax
cmpq $-0x1, %rax
je 0x903a
movl 0x4(%rsp), %ecx
movq 0x60(%r14), %rdx
movl %ecx, (%rdx,%rax,4)
movslq 0x8(%rsp), %rax
cmpq $-0x1, %rax
je 0x904d
movq 0x68(%r14), %rcx
movb $0x0, (%rcx,%rax)
movups 0x10(%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x20(%r14), %xmm0
movaps %xmm0, 0x30(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r13, %rdx
callq 0x9128
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x90f0
jmp 0x8fc6
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ys1998[P]spsim/src/main.cpp
// Function: print_regs(IntegerRegisterFile&, int*)
void print_regs(IntegerRegisterFile &rf, int *rmap){
	std::cout << "Integer Registers\n";
	for(int j=0; j<4; ++j){
		std::cout << "\033[0;36m  Register     Value\033[0m";
	}
	std::cout << "\n";
	for(int i=0; i < NUM_LOG_REGS/4; ++i){
		for(int j=0; j < 4; ++j){
			if(*(rmap + j*NUM_LOG_REGS/4 + i) != -1)
				std::cout << "\033[1;36m" <<
				std::setfill(' ') << std::setw(10) << j*NUM_LOG_REGS/4 + i << "\033[0m" <<
				std::setfill(' ') << std::setw(10) << rf.read(*(rmap + j*NUM_LOG_REGS/4 + i));
			else
				std::cout << "\033[1;36m" <<
				std::setfill(' ') << std::setw(10) << j*NUM_LOG_REGS/4 + i << "\033[0m" <<
				std::setfill(' ') << std::setw(10) << 0;
		}
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
movq 0xcbaf(%rip), %r15      # 0x16fd0
leaq 0x5ede(%rip), %rsi      # 0x10306
movq %r15, %rdi
callq 0x31d0
pushq $0x4
popq %rbp
leaq 0x5edf(%rip), %r12      # 0x10319
subl $0x1, %ebp
jb 0xa44c
movq %r15, %rdi
movq %r12, %rsi
callq 0x31d0
jmp 0xa43a
movq 0xcb7d(%rip), %rdi      # 0x16fd0
leaq 0x5ef7(%rip), %rsi      # 0x10351
callq 0x31d0
xorl %r15d, %r15d
pushq $0x20
popq %rbp
pushq $0xa
popq %r14
cmpq $0x8, %r15
je 0xa51c
xorl %r12d, %r12d
cmpq $0x20, %r12
je 0xa504
movl (%rbx,%r12,4), %r13d
movq 0xcb45(%rip), %rdi      # 0x16fd0
leaq 0x5ea7(%rip), %rsi      # 0x10339
callq 0x31d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
leal (%r15,%r12), %esi
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
leaq 0x5f40(%rip), %rsi      # 0x10403
callq 0x31d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
cmpl $-0x1, %r13d
je 0xa4f1
movslq (%rbx,%r12,4), %rcx
movq (%rsp), %rdx
movl (%rdx,%rcx,4), %esi
jmp 0xa4f3
xorl %esi, %esi
movq %rax, %rdi
callq 0x3310
addq $0x8, %r12
jmp 0xa476
movq 0xcac5(%rip), %rdi      # 0x16fd0
callq 0x3120
incq %r15
addq $0x4, %rbx
jmp 0xa469
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xca90(%rip), %r14      # 0x16fd0
leaq 0x5dfa(%rip), %rsi      # 0x10341
movq %r14, %rdi
callq 0x31d0
pushq $0x4
popq %rbp
leaq 0x5dfa(%rip), %r15      # 0x10353
subl $0x1, %ebp
jb 0xa56b
movq %r14, %rdi
movq %r15, %rsi
callq 0x31d0
jmp 0xa559
movq 0xca5e(%rip), %rdi      # 0x16fd0
leaq 0x5dd8(%rip), %rsi      # 0x10351
callq 0x31d0
xorl %r13d, %r13d
pushq $0x20
popq %rbp
pushq $0xa
popq %r14
leaq 0x5e74(%rip), %r12      # 0x10403
cmpq $0x19, %r13
je 0xa61b
xorl %r15d, %r15d
movq 0xca2d(%rip), %rdi      # 0x16fd0
cmpq $0x64, %r15
je 0xa60a
leaq 0x5d89(%rip), %rsi      # 0x10339
callq 0x31d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
leal (%r15,%r13), %esi
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
movl (%rbx,%r15,4), %esi
movq %rax, %rdi
callq 0x3310
addq $0x19, %r15
jmp 0xa59c
callq 0x3120
incq %r13
addq $0x4, %rbx
jmp 0xa58f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ys1998[P]spsim/inc/register.hpp
// Function: IntegerRegisterFile::IntegerRegisterFile()
IntegerRegisterFile() {								// default constructor
		for(int i=0; i < NUM_PHY_REGS; i++) {
			value[i] = 0;
		}
		hi = lo = 0;
	}

// Assembly:
xorl %eax, %eax
cmpq $0x40, %rax
je 0xbecd
andl $0x0, (%rdi,%rax,4)
incq %rax
jmp 0xbebe
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xb0, %rsp
movq 0x80(%rdi), %rsi
cmpb $0x1, 0x80(%rsi)
jne 0xc74a
movq %rdi, %rbx
cmpb $0x1, 0xb0(%rdi)
jne 0xc74a
leaq 0x30(%rsp), %rdi
callq 0x48ea
leaq 0x38(%rsp), %rsi
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x490c
movq 0x30(%rsp), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0xa4(%rbx)
leaq 0xab4e(%rip), %rax      # 0x171fc
movl (%rax), %eax
movl %eax, 0x50(%rbx)
cmpl $-0x1, 0xc(%rbx)
je 0xc73d
cmpl $-0x1, 0x8(%rbx)
je 0xc73d
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x7c7c
movl 0xc(%rsp), %ebp
leaq 0x3942(%rip), %rsi      # 0x1001d
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x4860
leaq 0xab17(%rip), %rdi      # 0x17208
leaq 0x10(%rsp), %rsi
callq 0x47fa
movl (%rax), %r14d
leaq 0x10(%rsp), %rdi
callq 0x3100
cmpl %r14d, %ebp
jne 0xc726
movl 0xa8(%rbx), %eax
movq 0x98(%rbx), %rcx
movslq 0xa4(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
jmp 0xc73d
movq 0x98(%rbx), %rax
movslq 0xa4(%rbx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xac(%rbx)
leaq 0x88(%rsp), %rdi
callq 0x3100
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3100
jmp 0xc76c
jmp 0xc769
jmp 0xc769
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
cmpl $-0x1, 0xc(%rdi)
je 0xc80c
movq %rdi, %rdx
cmpl $-0x1, 0x8(%rdi)
je 0xc80c
movq 0x88(%rdx), %r14
cmpb $0x1, 0x80(%r14)
jne 0xc7b7
movb $0x0, 0xb0(%rdx)
jmp 0xc80c
leaq 0x8(%rdx), %rbx
movb $0x1, 0xb0(%rdx)
addq $0xac, %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49ac
movq %r14, %rdi
movq %r15, %rsi
callq 0x493c
leaq 0x58(%rsp), %rdi
callq 0x3100
movq %rsp, %r14
movq %r14, %rdi
callq 0x6dd2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x490c
leaq 0x50(%rsp), %rdi
callq 0x3100
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0xc82b
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x88, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rdi), %r15
xorl %r12d, %r12d
leaq 0x68(%rsp), %r13
leaq 0x40(%rsp), %rbp
movq %r14, %rdi
callq 0x5968
cmpq %rax, %r12
jae 0xd06d
movq %r15, %rdi
movq %r12, %rsi
callq 0x5e92
cmpl %ebx, (%rax)
jle 0xd068
movups 0x10(%r14), %xmm0
movaps %xmm0, (%rsp)
movups 0x20(%r14), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r12, %rdx
callq 0x59b0
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5978
jmp 0xd005
incq %r12
jmp 0xd005
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5968
cmpq $0xf, %rax
ja 0xd0fb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5910
addq $0x58, %rbx
leaq 0x4(%rsp), %rsi
movl $0xfffffffe, (%rsi)     # imm = 0xFFFFFFFE
movq %rbx, %rdi
callq 0xdd0e
xorl %eax, %eax
jmp 0xd0fe
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdi, %rbx
movslq %esi, %r12
leaq 0x68(%rdi), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x872a
movl (%rax), %r15d
movl %r12d, %r13d
leaq 0x10(%rbx), %rax
movq %rax, 0x18(%rsp)
xorl %r12d, %r12d
movl %r15d, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq %rbx, %rdi
callq 0x5968
cmpq %rax, %r12
setae %al
cmpq %r13, %r12
setae %bpl
orb %al, %bpl
jne 0xd67f
movq %r14, %rdi
movq %r12, %rsi
callq 0x872a
cmpl (%rax), %r15d
jne 0xd677
movq %rbx, %r13
movq %r14, %rbx
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x5e92
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x7c7c
movl 0x24(%rsp), %r14d
leaq 0x28(%rsp), %r15
movq %r15, %rdi
leaq 0x29e4(%rip), %rsi      # 0x1001d
leaq 0x7(%rsp), %rdx
callq 0x4860
leaq 0x9bbe(%rip), %rdi      # 0x17208
movq %r15, %rsi
callq 0x47fa
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
callq 0x3100
cmpl 0xc(%rsp), %r14d
movq %rbx, %r14
movq %r13, %rbx
movl 0x8(%rsp), %r15d
movq 0x10(%rsp), %r13
je 0xd67f
incq %r12
jmp 0xd5d7
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x78, %rsp
movq %rsi, 0x20(%rsp)
movq 0xa8(%rdi), %rax
movq 0x10(%rax), %r14
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rbp
movl (%r14), %r15d
movq 0x20(%rsp), %rax
movl (%rax), %r12d
cmpl %r12d, %r15d
je 0xd7c8
movq %rbp, %r13
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x7c7c
movl 0x34(%rsp), %ebx
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
leaq 0x28fa(%rip), %rsi      # 0x1000c
leaq 0xf(%rsp), %rdx
callq 0x4860
leaq 0x9ae5(%rip), %rdi      # 0x17208
movq %rbp, %rsi
callq 0x47fa
cmpl (%rax), %ebx
jne 0xd73e
leaq 0x38(%rsp), %rdi
callq 0x3100
movq %r13, %rbp
jmp 0xd78f
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x7c7c
movq %r13, %rbp
movl 0x2c(%rsp), %ebx
movq %r13, %rdi
leaq 0x28b4(%rip), %rsi      # 0x10010
leaq 0xe(%rsp), %rdx
callq 0x4860
leaq 0x9a9b(%rip), %rdi      # 0x17208
movq %rbp, %rsi
callq 0x47fa
movl (%rax), %r13d
movq %rbp, %rdi
callq 0x3100
leaq 0x38(%rsp), %rdi
callq 0x3100
cmpl %r13d, %ebx
jne 0xd796
cmpb $0x0, 0x78(%r14)
je 0xd7c8
subq $-0x80, %r14
cmpq 0x18(%rsp), %r14
jne 0xd6db
movq 0x10(%rsp), %rax
movq 0x8(%rax), %r14
addq $0x8, %rax
movq %rax, 0x10(%rsp)
leaq 0x200(%r14), %rax
movq %rax, 0x18(%rsp)
jmp 0xd6db
cmpl %r12d, %r15d
sete %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd7f0
jmp 0xd7f0
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3100
jmp 0xd7f3
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
leaq 0x68(%rsi), %r13
leaq 0x10(%rsi), %rbp
leaq 0x70(%rsp), %r14
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbx
movq %r12, %rdi
callq 0x5968
cmpq %rax, %r15
jae 0xd8af
movq %r13, %rdi
movq %r15, %rsi
callq 0x872a
cmpl $-0x2, (%rax)
jne 0xd8aa
movq %r13, %rdi
movq %r15, %rsi
callq 0x872a
cmpl $-0x1, (%rax)
je 0xd8aa
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5e92
movq %rbx, %rdi
movq %rax, %rsi
callq 0x49ba
cmpl $-0x1, 0x24(%rsp)
je 0xd8a2
cmpl $-0x1, 0x20(%rsp)
je 0xd8a2
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x7c52
movq 0x50(%r12), %rax
movslq 0x18(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xd8f9
movq %r14, %rdi
callq 0x3100
incq %r15
jmp 0xd834
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x6dd2
leaq 0x20(%rsp), %rdx
orl $-0x1, (%rdx)
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xdcf0
leaq 0xe8(%rsp), %rdi
callq 0x3100
movq %r15, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movq %r15, %rsi
callq 0x872a
orl $-0x1, (%rax)
leaq 0xa0(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x20(%rsp), %rsi
callq 0x49ba
leaq 0x98(%rsp), %rsi
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xdab4
leaq 0xf0(%rsp), %rdi
callq 0x3100
movq %r14, %rdi
jmp 0xd8df
jmp 0xd946
movq %rax, %rbx
movq %r14, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xb8, %rsp
movl %esi, 0x4(%rsp)
movq %rdi, %r14
leaq 0x10(%rdi), %r15
leaq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0x30(%rsp), %rbp
leaq 0x10(%rsp), %r12
leaq 0x98(%rsp), %rbx
movq %r14, %rdi
callq 0x5968
cmpq %rax, %r13
jae 0xda5a
movq %r15, %rdi
movq %r13, %rsi
callq 0x5e92
movl 0x4(%rsp), %ecx
cmpl %ecx, (%rax)
jle 0xda52
movups 0x10(%r14), %xmm0
movaps %xmm0, 0x10(%rsp)
movups 0x20(%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x59b0
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x70(%rsp), %rdx
callq 0x5978
movups 0x68(%r14), %xmm0
movaps %xmm0, 0x10(%rsp)
movups 0x78(%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x8749
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xda6c
jmp 0xd994
incq %r13
jmp 0xd994
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ys1998[P]spsim/src/writer.cpp
// Function: Writer::tock()
void Writer::tock(void){
	Instruction i1 = std::get<0>(t1), i2 = std::get<0>(t2), i3 = std::get<0>(t3);
	if(i1.is_valid()){
		i1.WB = CLOCK;
		a->graduate(i1);
		Instruction reset; t1 = std::make_tuple(reset, 0);
	}
	if(i2.is_valid()){
		i2.WB = CLOCK;
		a->graduate(i2);
		Instruction reset; t2 = std::make_tuple(reset, 0, 0);
	}
	if(i3.is_valid()){
		i3.WB = CLOCK;
		a->graduate(i3);
		Instruction reset; t3 = std::make_tuple(reset, 0);
	}
}

// Assembly:
pushq %rbx
subq $0x260, %rsp            # imm = 0x260
movq %rdi, %rbx
leaq 0x10(%rdi), %rsi
leaq 0x1e8(%rsp), %rdi
callq 0x49ba
leaq 0x110(%rbx), %rsi
leaq 0x170(%rsp), %rdi
callq 0x49ba
leaq 0x90(%rbx), %rsi
leaq 0xf8(%rsp), %rdi
callq 0x49ba
cmpl $-0x1, 0x1ec(%rsp)
je 0xec0f
cmpl $-0x1, 0x1e8(%rsp)
je 0xec0f
leaq 0x8647(%rip), %rax      # 0x171fc
movl (%rax), %eax
leaq 0x1e8(%rsp), %rsi
movl %eax, 0x4c(%rsi)
movq 0x1a0(%rbx), %rdi
callq 0x8e92
movq %rsp, %rdi
callq 0x6dd2
leaq 0x80(%rsp), %rdi
andl $0x0, -0x8(%rdi)
movq %rsp, %rsi
callq 0x49ba
leaq 0x8(%rbx), %rdi
leaq 0x78(%rsp), %rsi
callq 0xef90
leaq 0xd0(%rsp), %rdi
callq 0x3100
leaq 0x50(%rsp), %rdi
callq 0x3100
cmpl $-0x1, 0x174(%rsp)
je 0xec88
cmpl $-0x1, 0x170(%rsp)
je 0xec88
leaq 0x85d2(%rip), %rax      # 0x171fc
movl (%rax), %eax
leaq 0x170(%rsp), %rsi
movl %eax, 0x4c(%rsi)
movq 0x1a0(%rbx), %rdi
callq 0x8e92
movq %rsp, %rdi
callq 0x6dd2
leaq 0x80(%rsp), %rdi
andq $0x0, -0x8(%rdi)
movq %rsp, %rsi
callq 0x49ba
leaq 0x108(%rbx), %rdi
leaq 0x78(%rsp), %rsi
callq 0xefa6
leaq 0xd0(%rsp), %rdi
callq 0x3100
leaq 0x50(%rsp), %rdi
callq 0x3100
cmpl $-0x1, 0xfc(%rsp)
je 0xed03
cmpl $-0x1, 0xf8(%rsp)
je 0xed03
leaq 0x8559(%rip), %rax      # 0x171fc
movl (%rax), %eax
leaq 0xf8(%rsp), %rsi
movl %eax, 0x4c(%rsi)
movq 0x1a0(%rbx), %rdi
callq 0x8e92
movq %rsp, %rdi
callq 0x6dd2
leaq 0x80(%rsp), %rdi
andl $0x0, -0x8(%rdi)
movq %rsp, %rsi
callq 0x49ba
addq $0x88, %rbx
leaq 0x78(%rsp), %rsi
movq %rbx, %rdi
callq 0xef90
leaq 0xd0(%rsp), %rdi
callq 0x3100
leaq 0x50(%rsp), %rdi
callq 0x3100
leaq 0x148(%rsp), %rdi
callq 0x3100
leaq 0x1c0(%rsp), %rdi
callq 0x3100
leaq 0x238(%rsp), %rdi
callq 0x3100
addq $0x260, %rsp            # imm = 0x260
popq %rbx
retq
jmp 0xed3b
jmp 0xed56
jmp 0xed3b
jmp 0xed56
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3100
jmp 0xed59
jmp 0xed56
movq %rax, %rbx
jmp 0xed66
movq %rax, %rbx
jmp 0xed73
movq %rax, %rbx
leaq 0x148(%rsp), %rdi
callq 0x3100
leaq 0x1c0(%rsp), %rdi
callq 0x3100
leaq 0x238(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/ys1998[P]spsim/src/writer.cpp
// Function: Writer::flush(int)
void Writer::flush(int id){
	if(in1->valid()){
		auto inp = in1->read();
		auto iRead = std::get<0>(inp);
		auto inp1 = std::get<1>(inp);
		if(iRead.get_id() < id){
			in1->write(std::make_tuple(iRead, inp1));
		}
	}
	if(in3->valid()){
		auto inp = in3->read();
		auto iRead = std::get<0>(inp);
		auto inp1 = std::get<1>(inp);
		if(iRead.get_id() < id){
			in3->write(std::make_tuple(iRead, inp1));
		}
	}
	if(in2->valid()){
		auto inp = in2->read();
		auto iRead = std::get<0>(inp);
		auto inp1 = std::get<1>(inp);
		auto inp2 = std::get<2>(inp);
		if(iRead.get_id() < id){
			in2->write(std::make_tuple(iRead, inp1, inp2 ));
		}
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movl %esi, %ebp
movq %rdi, %rbx
movq 0x188(%rdi), %rsi
cmpb $0x1, 0x80(%rsi)
jne 0xee24
leaq 0x80(%rsp), %rdi
callq 0x86f0
leaq 0x88(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x49ba
cmpl %ebp, 0x8(%rsp)
jge 0xee0d
movl 0x80(%rsp), %eax
movq 0x188(%rbx), %r14
leaq 0x108(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
callq 0x49ba
leaq 0x100(%rsp), %rsi
movq %r14, %rdi
callq 0x493c
leaq 0x158(%rsp), %rdi
callq 0x3100
leaq 0x58(%rsp), %rdi
callq 0x3100
leaq 0xd8(%rsp), %rdi
callq 0x3100
movq 0x190(%rbx), %rsi
cmpb $0x1, 0x80(%rsi)
jne 0xeeb0
leaq 0x80(%rsp), %rdi
callq 0x86f0
leaq 0x88(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x49ba
cmpl %ebp, 0x8(%rsp)
jge 0xee99
movl 0x80(%rsp), %eax
movq 0x190(%rbx), %r14
leaq 0x108(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
callq 0x49ba
leaq 0x100(%rsp), %rsi
movq %r14, %rdi
callq 0x493c
leaq 0x158(%rsp), %rdi
callq 0x3100
leaq 0x58(%rsp), %rdi
callq 0x3100
leaq 0xd8(%rsp), %rdi
callq 0x3100
movq 0x198(%rbx), %rsi
cmpb $0x1, 0x80(%rsi)
jne 0xef3e
leaq 0x80(%rsp), %rdi
callq 0x48ea
leaq 0x88(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x49ba
cmpl %ebp, 0x8(%rsp)
jge 0xef27
movq 0x198(%rbx), %rbx
movq 0x80(%rsp), %rax
leaq 0x108(%rsp), %rdi
movq %rax, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
callq 0x49ba
leaq 0x100(%rsp), %rsi
movq %rbx, %rdi
callq 0x4900
leaq 0x158(%rsp), %rdi
callq 0x3100
leaq 0x58(%rsp), %rdi
callq 0x3100
leaq 0xd8(%rsp), %rdi
callq 0x3100
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xef52
jmp 0xef64
jmp 0xef52
jmp 0xef64
movq %rax, %rbx
leaq 0x158(%rsp), %rdi
callq 0x3100
jmp 0xef67
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3100
jmp 0xef7a
jmp 0xef77
jmp 0xef77
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2447
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x2140
movl %eax, %edi
callq 0x2150
testl %ebx, %ebx
cmovlel %r15d, %ebx
testl %r14d, %r14d
cmovlel %r15d, %r14d
incl %r14d
pushq $0x1
popq %r15
pushq $0x64
popq %rbp
cmpq %r14, %r15
je 0x2543
imulq $0x18, %r15, %r12
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x253e
callq 0x2040
cltd
idivl %ebp
xorl %eax, %eax
cmpl $0x31, %edx
setl %al
movq 0x4c40(%rip), %rcx      # 0x7170
movq (%rcx,%r12), %rcx
movl %eax, 0x4(%rcx,%r13,4)
incq %r13
jmp 0x2514
incq %r15
jmp 0x2508
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2447
movq 0x4c11(%rip), %rdx      # 0x7170
movq 0x60(%rdx), %rcx
pushq $0x1
popq %rax
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_O2/eugene87222[P]Game-of-Life/gol.cpp
// Function: Simkinglidergun(int, int)
void Simkinglidergun(int height, int width) {
    emptyBoard(height, width);

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

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

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

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

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

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

// Assembly:
pushq %rax
callq 0x2447
movq 0x4b47(%rip), %rcx      # 0x7170
movq 0x1f8(%rcx), %rdx
pushq $0x1
popq %rax
movl %eax, 0x8(%rdx)
movq 0x210(%rcx), %rsi
movl %eax, 0x8(%rsi)
movl %eax, 0xc(%rdx)
movl %eax, 0xc(%rsi)
movq 0x1b0(%rcx), %rdi
movl %eax, 0x18(%rdi)
movq 0x1c8(%rcx), %r8
movl %eax, 0x18(%r8)
movl %eax, 0x1c(%rdi)
movl %eax, 0x1c(%r8)
movl %eax, 0x24(%rdx)
movl %eax, 0x24(%rsi)
movl %eax, 0x28(%rdx)
movl %eax, 0x28(%rsi)
movq 0x60(%rcx), %rdx
movl %eax, 0x58(%rdx)
movq 0x78(%rcx), %rdx
movl %eax, 0x58(%rdx)
movq 0x48(%rcx), %rsi
movl %eax, 0x5c(%rsi)
movl %eax, 0x5c(%rdx)
movl %eax, 0x60(%rsi)
movq 0x30(%rcx), %rdx
movl %eax, 0x64(%rdx)
movl %eax, 0x64(%rsi)
movq 0xf0(%rcx), %rdx
movl %eax, 0x5c(%rdx)
movq 0x108(%rcx), %rsi
movl %eax, 0x5c(%rsi)
movq 0x120(%rcx), %rdi
movl %eax, 0x5c(%rdi)
movl %eax, 0x60(%rdx)
movq 0x138(%rcx), %r8
movl %eax, 0x60(%r8)
movl %eax, 0x64(%rdx)
movl %eax, 0x64(%r8)
movl %eax, 0x6c(%r8)
movq 0xd8(%rcx), %rcx
movl %eax, 0x70(%rcx)
movl %eax, 0x70(%r8)
movl %eax, 0x74(%rdx)
movl %eax, 0x74(%rdi)
movl %eax, 0x78(%rsi)
movl %eax, 0x84(%rdx)
movl %eax, 0x84(%rsi)
movl %eax, 0x88(%rdx)
movl %eax, 0x88(%rsi)
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
movslq %edx, %rax
movslq %ecx, %rcx
movslq %edi, %rdx
movslq %esi, %rsi
movl $0x1, %edi
cmpq %rsi, %rdx
jg 0x2793
imulq $0x18, %rdx, %r8
movq 0x4a51(%rip), %r9       # 0x7170
addq %r8, %r9
addq 0x4a5f(%rip), %r8       # 0x7188
movq %rax, %r10
cmpq %rcx, %r10
jg 0x278b
movq -0x18(%r9), %rbx
movq (%r9), %r14
movl (%rbx,%r10,4), %r11d
addl -0x4(%rbx,%r10,4), %r11d
addl 0x4(%rbx,%r10,4), %r11d
addl -0x4(%r14,%r10,4), %r11d
addl 0x4(%r14,%r10,4), %r11d
movq 0x18(%r9), %rbx
addl -0x4(%rbx,%r10,4), %r11d
addl (%rbx,%r10,4), %r11d
addl 0x4(%rbx,%r10,4), %r11d
cmpl $0x1, (%r14,%r10,4)
jne 0x2777
addl $-0x4, %r11d
xorl %ebx, %ebx
cmpl $-0x2, %r11d
jb 0x277f
jmp 0x2786
movl %edi, %ebx
cmpl $0x3, %r11d
jne 0x2786
movq (%r8), %r11
movl %ebx, (%r11,%r10,4)
incq %r10
jmp 0x272c
incq %rdx
jmp 0x270f
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
leaq 0x49e1(%rip), %rdi      # 0x7188
leaq 0x49c2(%rip), %rsi      # 0x7170
callq 0x2f16
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
testl %r14d, %r14d
cmovlel %eax, %r14d
incl %r14d
pushq $0x1
popq %rax
pushq $0x1
popq %rcx
cmpq %r14, %rax
je 0x2854
imulq $0x18, %rax, %rdx
movq 0x4992(%rip), %rsi      # 0x7170
addq %rdx, %rsi
addq 0x49a0(%rip), %rdx      # 0x7188
xorl %edi, %edi
cmpq %rdi, %rbx
je 0x284c
movq -0x18(%rsi), %r9
movq (%rsi), %r10
movl 0x4(%r9,%rdi,4), %r8d
addl (%r9,%rdi,4), %r8d
addl 0x8(%r9,%rdi,4), %r8d
addl (%r10,%rdi,4), %r8d
addl 0x8(%r10,%rdi,4), %r8d
movq 0x18(%rsi), %r9
addl (%r9,%rdi,4), %r8d
addl 0x4(%r9,%rdi,4), %r8d
addl 0x8(%r9,%rdi,4), %r8d
cmpl $0x1, 0x4(%r10,%rdi,4)
jne 0x2836
addl $-0x4, %r8d
xorl %r9d, %r9d
cmpl $-0x2, %r8d
jb 0x283f
jmp 0x2847
movl %ecx, %r9d
cmpl $0x3, %r8d
jne 0x2847
movq (%rdx), %r8
movl %r9d, 0x4(%r8,%rdi,4)
incq %rdi
jmp 0x27ea
incq %rax
jmp 0x27ca
leaq 0x4915(%rip), %rdi      # 0x7170
leaq 0x4926(%rip), %rsi      # 0x7188
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2f16
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23c8
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq 0x20(%r15), %rdi
callq 0x2150
addq $0x8, %r14
leaq 0x3cf5(%rip), %r12      # 0x6091
movq %r15, %rdi
callq 0x2160
cmpq %r14, %rax
je 0x23bf
movq %rax, %r15
movq 0x20(%rax), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21b0
jmp 0x239c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c81(%rip), %rdi      # 0x6050
leaq 0x3c83(%rip), %rsi      # 0x6059
leaq 0x3c89(%rip), %rcx      # 0x6066
pushq $0x5d
popq %rdx
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r15
cmpq 0x8(%rdi), %r15
je 0x2428
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3c8f(%rip), %rsi      # 0x6096
leaq 0x3c87(%rip), %r12      # 0x6095
movl (%r15), %edx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21b0
addq $0x4, %r15
movq %r12, %rsi
cmpq 0x8(%r14), %r15
jne 0x240e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2200
testl %eax, %eax
je 0x2464
andb $0x1f, %r14b
decb %r14b
pushq $0x1
popq %rax
movl %r14d, %ecx
shll %cl, %eax
movl (%rbx), %ecx
movzbl %r14b, %edx
btl %edx, %ecx
jae 0x2468
xorl %eax, %eax
jmp 0x2471
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_O2/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
andl $0x0, 0x8(%rdi)
leaq 0x8(%rdi), %rax
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, -0x48(%rbp)
movq %rax, 0x20(%rdi)
leaq 0x28(%rdi), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movl %edx, 0x48(%rdi)
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movb $0x0, (%rax)
leaq -0x68(%rbp), %r13
leaq -0x2c(%rbp), %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x259d
testb %al, %al
je 0x2519
movq -0x68(%rbp), %rdi
movl %r15d, %esi
callq 0x25ec
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x24df
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35ba
movq %rax, %rdi
movq %r13, %rsi
callq 0x4198
jmp 0x24df
leaq -0x68(%rbp), %rdi
callq 0x20a0
movq -0x40(%rbp), %rax
movq (%rax), %rsi
testq %rsi, %rsi
movq -0x38(%rbp), %r15
movq -0x48(%rbp), %r12
je 0x2560
movq %r15, %rdi
callq 0x360c
movq 0x18(%rbx), %r14
cmpq %r12, %r14
je 0x2560
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x36a6
movq %r14, %rdi
callq 0x2160
movq %rax, %r14
jmp 0x2542
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2571
movq %rax, %r14
jmp 0x2584
jmp 0x2578
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x20a0
movq -0x38(%rbp), %rdi
callq 0x3d52
movq %rbx, %rdi
callq 0x3994
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x8(%rsi)
movq %rdi, %r14
movq (%rsi), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x2070
cmpl $0xa, %eax
je 0x25e5
cmpl $-0x1, %eax
je 0x25db
movl %eax, %edi
callq 0x2240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2110
jmp 0x25b5
cmpq $0x0, 0x8(%rbx)
setne %al
jmp 0x25e7
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%r15)
movb (%r14), %al
testb %al, %al
je 0x2620
incq %r14
movsbl %al, %esi
movq %r15, %rdi
callq 0x2432
testb %al, %al
jne 0x2603
xorl %eax, %eax
jmp 0x262a
xorl %eax, %eax
cmpl %ebx, -0x1c(%rbp)
jne 0x262a
movl -0x20(%rbp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2763
movq (%r14), %rdx
cmpq 0x8(%r14), %rdx
je 0x2782
movq %rdi, %r12
cmpq %rcx, %rax
je 0x26d8
movq (%rax), %rdx
cmpq %rdx, 0x8(%rax)
je 0x26cd
movq %rdx, 0x8(%rax)
movq 0x8(%r12), %rcx
andq $0x0, 0x18(%rax)
addq $0x20, %rax
jmp 0x26b6
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 0x2744
shll $0x5, %edi
addq (%r12), %rdi
movq %r15, %rsi
callq 0x2636
addq $0x4, %r13
cmpq 0x8(%r14), %r13
jne 0x26e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x39cb(%rip), %rdi      # 0x6116
leaq 0x3907(%rip), %rsi      # 0x6059
leaq 0x3966(%rip), %rcx      # 0x60bf
movl $0x156, %edx            # imm = 0x156
callq 0x20c0
leaq 0x392f(%rip), %rdi      # 0x6099
leaq 0x38e8(%rip), %rsi      # 0x6059
leaq 0x3947(%rip), %rcx      # 0x60bf
movl $0x14e, %edx            # imm = 0x14E
callq 0x20c0
leaq 0x3981(%rip), %rdi      # 0x610a
leaq 0x38c9(%rip), %rsi      # 0x6059
leaq 0x3928(%rip), %rcx      # 0x60bf
movl $0x14f, %edx            # imm = 0x14F
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchblank[P]qiksolve/qiksolve.cpp
// Function: DividedWordList::entropy() const
double DividedWordList::entropy() const
{
	size_t total_count = 0;
	bool perfect_split = true;
	for (auto it = cbegin(); it != cend(); ++it) {
		total_count += it->count();
		if (it->choices().size() > 1)
			perfect_split = false;
	}
	if (perfect_split) {
		// We can't do better than this -- by making this choice
		// we'll end up at the endgame
		return numeric_limits<double>::max();
	}
	double answer = 0.0;
	double const d_total = static_cast<double>(total_count);
	for (auto it = cbegin(); it != cend(); ++it)
		if (it->count() > 0) {
			double const prob = static_cast<double>(it->count()) / d_total;
			answer += prob * log(prob);
		}
	return -answer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
movb $0x1, %dl
xorl %ecx, %ecx
movq %r14, %rsi
cmpq %rax, %rsi
je 0x27df
addq 0x18(%rsi), %rcx
movq 0x8(%rsi), %rdi
subq (%rsi), %rdi
cmpq $0x5, %rdi
setb %dil
andb %dil, %dl
addq $0x20, %rsi
jmp 0x27be
testb $0x1, %dl
je 0x27f1
movsd 0x381c(%rip), %xmm0     # 0x6008
jmp 0x2888
movq %rcx, %xmm0
punpckldq 0x3822(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x382a(%rip), %xmm0     # 0x6030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, -0x30(%rbp)
xorpd %xmm0, %xmm0
cmpq %rax, %r14
je 0x2880
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x287a
movapd %xmm0, -0x20(%rbp)
movq %rcx, %xmm1
punpckldq 0x37e5(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x37ed(%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 0x20f0
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
jmp 0x281b
xorpd 0x37b8(%rip), %xmm0     # 0x6040
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23e6
movq 0x10(%r14), %rsi
leaq 0x370c(%rip), %rdi      # 0x61f9
callq 0x2150
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
movl %r15d, %edx
callq 0x3776
movsd -0x28(%rbp), %xmm0
ucomisd 0x34f9(%rip), %xmm0     # 0x6008
movq 0x10(%r14), %rsi
jne 0x2b25
jp 0x2b25
leaq 0x36df(%rip), %rdi      # 0x61fd
callq 0x2150
jmp 0x2b39
leaq 0x36d5(%rip), %rax      # 0x6201
movq %rsi, %rdi
movq %rax, %rsi
movb $0x1, %al
callq 0x21b0
movq (%rbx), %r12
movq 0x10(%r14), %rdi
movl 0x18(%r12), %edx
leaq 0x354a(%rip), %rsi      # 0x6096
xorl %eax, %eax
callq 0x21b0
addq $0x20, %r12
leaq 0x36a9(%rip), %r15      # 0x6207
movq 0x10(%r14), %rsi
cmpq 0x8(%rbx), %r12
je 0x2b80
movl 0x18(%r12), %edx
movq %rsi, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21b0
addq $0x20, %r12
jmp 0x2b5e
pushq $0xa
popq %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/mitchblank[P]qiksolve/qiksolve.cpp
// Function: SolutionPrinter::acceptSolution(AnswerSequence const&, unsigned int)
void SolutionPrinter::acceptSolution(AnswerSequence const& sequence, Word const word)
{
	sequence.describe(fout_);
	fputs(",Y,", fout_);
	dict_.describeWord(fout_, word);
	fputs(",,\n", fout_);
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r15
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
movq (%rsi), %r13
leaq -0x48(%rbp), %r12
cmpq 0x8(%r15), %r13
je 0x2c98
movl (%r13), %esi
movq %r12, %rdi
callq 0x2d0e
addq $0x4, %r13
jmp 0x2c80
leaq 0x8(%r14), %r15
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x4504
addq $0x10, %r14
cmpq %r14, %rax
jne 0x2cd7
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x37d2
movl %ebx, (%rax)
leaq -0x48(%rbp), %rdi
callq 0x20a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3535(%rip), %rdi      # 0x6213
leaq 0x3374(%rip), %rsi      # 0x6059
leaq 0x3544(%rip), %rcx      # 0x6230
movl $0x207, %edx            # imm = 0x207
callq 0x20c0
jmp 0x2cfa
jmp 0x2cfa
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2230