LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::OFB_decrypt()
void Cipher::OFB_decrypt(){     
    Sequence tag = CBC_MAC(*inputBlock, false, true);             //Generate MAC Tag from Ciphertext
    Sequence readTag = inputBlock->getSequenceVector().at(0);     //Get the MAC Tag in the Ciphertext
    if(authenticateSequences(&readTag, &tag)){          //Authenticate Ciphertext
        Sequence ivSq(16);
        int i = -1;

        //Decrypt Ciphertext
        for(Sequence sq: inputBlock->getSequenceVector()) {
            i++;
            if(i <= 1) {
                ivSq.updateSequence(sq);    //Ignore first 2 block when decrypting, since these
                continue;                   //Contain MAC Tag and IV respectively
            }
            encrypt(&ivSq, aesKeyExp);
            sq = sq ^ ivSq; 
        }

        //Ciphertext has been authenticated and decrypted. Ready to write plaintext
        writePlainText();
    } else
        throw "Ciphertext has been modified, it won't be decrypted!\n";     //Authenticate-then-decrypt
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x644a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x580a
movq %rax, 0x18(%rsp)
movl %edx, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x353c
movq 0x10(%rbx), %rdi
callq 0x3572
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x626d
movups (%rcx), %xmm0
leaq 0x50(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x18(%rsp), %rdx
callq 0x59bc
testb %al, %al
je 0x627f
leaq 0x28(%rsp), %rdi
movl $0x10, %esi
callq 0x31dc
movq 0x10(%rbx), %rdi
callq 0x3572
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x6256
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x28(%rsp), %r14
movq %rsp, %r15
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
testl %ebp, %ebp
jle 0x623b
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5278
movq %r15, %rdi
movq %r14, %rsi
callq 0x335d
jmp 0x624b
movq (%rsp), %rsi
movl 0x8(%rsp), %edx
movq %r14, %rdi
callq 0x327e
addq $0x10, %r12
incl %ebp
cmpq %r13, %r12
jne 0x6213
movq %rbx, %rdi
callq 0x5ab2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1580(%rip), %rdi      # 0x77f4
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2330
movl $0x8, %edi
callq 0x2120
leaq 0x1503(%rip), %rcx      # 0x7793
movq %rcx, (%rax)
movq 0x4d26(%rip), %rsi      # 0xafc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x23d0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x353c
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::init()
void Bjorklund::init(){
    try{
        iter();
        
    }catch(out_of_range){
        cerr<<"pulse::out_of_range"<<'\n';
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
callq 0x34d2
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x34c1
movq %rbx, %rdi
callq 0x2140
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x21c0
movq 0x3b5d(%rip), %rax      # 0x6fb8
addq $0x10, %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x2070
movq 0x3b7f(%rip), %rdi      # 0x6ff0
leaq 0x1c13(%rip), %rsi      # 0x508b
movl $0x13, %edx
callq 0x2130
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x3b5f(%rip), %rdi      # 0x6ff0
movl $0x1, %edx
callq 0x2130
leaq 0x8(%rsp), %rdi
callq 0x2208
callq 0x21a0
jmp 0x3428
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2208
callq 0x21a0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2bd5
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::init(int, int)
void Bjorklund::init(int step, int pulse){
    lengthOfSeq = step;
    pulseAmt = pulse;
    
    try{
        iter();
        
    }catch(out_of_range){
        cerr<<"pulse::out_of_range"<<'\n';
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, 0x58(%rdi)
movl %edx, 0x5c(%rdi)
callq 0x34d2
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x3759
movq %rbx, %rdi
callq 0x2140
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x21c0
movq 0x38c5(%rip), %rax      # 0x6fb8
addq $0x10, %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x2070
movq 0x38e7(%rip), %rdi      # 0x6ff0
leaq 0x197b(%rip), %rsi      # 0x508b
movl $0x13, %edx
callq 0x2130
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x38c7(%rip), %rdi      # 0x6ff0
movl $0x1, %edx
callq 0x2130
leaq 0x8(%rsp), %rdi
callq 0x2208
callq 0x21a0
jmp 0x36c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2208
callq 0x21a0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2bd5
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::buildSeq(int)
void Bjorklund::buildSeq(int slot){
    //construct a binary sequence of n bits with k one‚Äôs, such that the k one‚Äôs are distributed as evenly as possible among the zero‚Äôs
    
    if (slot == -1) {
        sequence.push_back(0);
    }
    else if (slot == -2)  {
        sequence.push_back(1);
    }else{
        for (int i = 0; i < count[slot]; i++)
            buildSeq(slot-1);
        if (remainder[slot] !=0)
            buildSeq(slot-2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
cmpl $-0x2, %r14d
je 0x37c9
cmpl $-0x1, %r14d
je 0x37c5
movq 0x18(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
jle 0x37ac
leal -0x1(%r14), %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x376a
incl %r15d
movq 0x18(%rbx), %rax
cmpl (%rax,%r14,4), %r15d
jl 0x3795
movq (%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
leaq -0x2(%r14), %r14
jne 0x3777
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x37cb
movb $0x1, %al
addq $0x30, %rbx
movzbl %al, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x398e
// File: /workspace/github_cpp_makefile_star2_O3/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::print()
void Bjorklund::print(){
    for(int i=0; i != sequence.size();i++){
        cout<<sequence.at(i);
    }
    cout<<'\n';
    cout<<"Size : "<<sequence.size()<<'\n';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movl 0x48(%rdi), %ecx
subq 0x30(%rdi), %rax
shlq $0x3, %rax
addq %rcx, %rax
je 0x3848
leaq 0x30(%rbx), %r14
xorl %r15d, %r15d
movq 0x37ab(%rip), %r12      # 0x6fc0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3928
xorl %esi, %esi
testq %rdx, (%rax)
setne %sil
movq %r12, %rdi
callq 0x21b0
incq %r15
movq 0x40(%rbx), %rax
movl 0x48(%rbx), %ecx
subq 0x30(%rbx), %rax
leaq (%rcx,%rax,8), %rax
cmpq %rax, %r15
jne 0x3815
movb $0xa, %bpl
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movq 0x3766(%rip), %r14      # 0x6fc0
movl $0x1, %edx
movq %r14, %rdi
callq 0x2130
leaq 0x1852(%rip), %rsi      # 0x50c0
movl $0x7, %edx
movq %r14, %rdi
callq 0x2130
movq 0x40(%rbx), %rax
movl 0x48(%rbx), %ecx
subq 0x30(%rbx), %rax
leaq (%rcx,%rax,8), %rsi
movq %r14, %rdi
callq 0x20b0
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2130
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::LoadSequence()
vector<bool> Bjorklund::LoadSequence(){
    vector<bool> seq;
    for(int i=0;i < lengthOfSeq;i++){
        seq.push_back(sequence[i]);
    }
    return seq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r15, (%rdi)
movl %r15d, 0x8(%rdi)
movq %r15, 0x10(%rdi)
movl %r15d, 0x18(%rdi)
movq %r15, 0x20(%rdi)
cmpl %r15d, 0x58(%rsi)
jle 0x3904
movq %rsi, %r14
movq 0x30(%r14), %rax
movl %r15d, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
xorl %esi, %esi
btq %r15, %rax
setb %sil
movq %rbx, %rdi
callq 0x398e
incl %r15d
cmpl 0x58(%r14), %r15d
jl 0x38db
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2be0
movq %r14, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2bd5
// File: /workspace/github_cpp_makefile_star2_O3/JayWalker512[P]JayParser/VM.cpp
// Function: VM::parse()
void VM::parse()
{
	parseDataSection();
	
	if (m_log->getErrorCount())
		return;

	parseCodeSection();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2de2
movq 0x40048(%rbx), %rax
movq 0x48(%rax), %rcx
movl 0x28(%rax), %edx
movl %ecx, %esi
subl %edx, %esi
shrl $0x3, %esi
cmpq $0x1, %rcx
adcl $-0x1, %esi
shll $0x6, %esi
movq 0x20(%rax), %rcx
movq 0x30(%rax), %rdx
subq 0x38(%rax), %rdx
shrq $0x3, %rdx
addl %esi, %edx
subq 0x10(%rax), %rcx
shrq $0x3, %rcx
addl %edx, %ecx
je 0x2dd4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2f7a
// File: /workspace/github_cpp_makefile_star2_O3/JayWalker512[P]JayParser/VM.cpp
// Function: VM::parseDataSection()
void VM::parseDataSection()
{	
	jumpToSection(DATASEC);
	
	// Parse
	while (!m_program->eof()) {
		readNextOperators();
		
		if ((uint)((m_op1 << 16) + m_op2) == CODESEC)
			return;
		
		for (uint i = 0; i < m_op1; ++i) {
			m_memory[m_op2 + i] = m_program->get();
		}
	}
	
	m_log->add(new Error(FATAL + PARSERR + 5, "Infinite data section."));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl $0xddffddff, %esi       # imm = 0xDDFFDDFF
callq 0x33ec
movq 0x40040(%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
jne 0x2e98
leaq 0x4002c(%rbx), %r14
leaq 0x40030(%rbx), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x338c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x338c
movl 0x4002c(%rbx), %eax
movl %eax, %ecx
shll $0x10, %ecx
addl 0x40030(%rbx), %ecx
cmpl $0xccffccff, %ecx       # imm = 0xCCFFCCFF
je 0x2f36
testl %eax, %eax
je 0x2e83
xorl %r12d, %r12d
movq 0x40040(%rbx), %rdi
callq 0x2150
movl 0x40030(%rbx), %ecx
addl %r12d, %ecx
movl %eax, (%rbx,%rcx,4)
incl %r12d
cmpl 0x4002c(%rbx), %r12d
jb 0x2e5f
movq 0x40040(%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
je 0x2e25
movq 0x40048(%rbx), %r14
movl $0x28, %edi
callq 0x2120
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x12bc(%rip), %rsi      # 0x4177
leaq 0x12cb(%rip), %rdx      # 0x418d
leaq -0x40(%rbp), %rdi
callq 0x2c54
movl $0x80ffee05, (%rbx)     # imm = 0x80FFEE05
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
movb $0x1, %r12b
callq 0x2bb6
movq %rbx, -0x48(%rbp)
movq 0x30(%r14), %rax
movq 0x40(%r14), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x2f12
movq %rbx, (%rax)
addq $0x8, 0x30(%r14)
jmp 0x2f21
xorl %r12d, %r12d
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x29a4
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f36
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2130
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2f65
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f60
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2130
testb %r12b, %r12b
je 0x2f72
movl $0x28, %esi
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/JayWalker512[P]JayParser/VM.cpp
// Function: VM::readNextInstruction()
void VM::readNextInstruction()
{
	char buffer;
	m_program->get(buffer);
	
	m_instruction = (unsigned char)buffer;	
	++m_ic;
	
	switch (m_instruction) {
		case NOP:
		case DSP:
		case RSTLG:
		case JMP:
		case JMF:
		case JMPMK:
		case NOT:
			return;
		case DEC:
		case INC:
		case NEG:
			readNextOp1();
			return;
		case MOV:
		case SET:
		case ADD:
		case SUB:
		case MUL:
		case DIV:
		case EQQ:
		case NEQ:
		case AND:
		case ORR:
			readNextOperators();
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x40040(%rdi), %rdi
leaq -0x11(%rbp), %r14
movq %r14, %rsi
callq 0x2170
movzbl (%r14), %eax
incl 0x40020(%rbx)
movl %eax, 0x40028(%rbx)
cmpq $0x23, %rax
ja 0x3366
movabsq $0xf000f000c, %rcx      # imm = 0xF000F000C
btq %rax, %rcx
jae 0x334b
leaq 0x4002c(%rbx), %rsi
movq %rbx, %rdi
callq 0x338c
movl $0x40030, %esi          # imm = 0x40030
jmp 0x335b
movl $0x4002c, %esi          # imm = 0x4002C
movl $0x2300000, %ecx        # imm = 0x2300000
btq %rax, %rcx
jae 0x3366
addq %rbx, %rsi
movq %rbx, %rdi
callq 0x338c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JayWalker512[P]JayParser/VM.cpp
// Function: VM::jumpToSection(unsigned int)
void VM::jumpToSection(uint section)
{
	uint buffer = 0;
	
	m_program->seekg(0, std::ios_base::beg);
	
	// Fill the buffer
	readNextSection(&buffer);
	readNextSection(&buffer);
	readNextSection(&buffer);
	
	do {
		readNextSection(&buffer);
		if (buffer == section)
			return;
	} while (!m_program->eof());
	
	m_log->add(new Error(FATAL + PARSERR + 4, "Cannot find requested section."));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x40040(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2160
movq 0x40040(%rbx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x2170
movzbl (%r15), %r12d
movq 0x40040(%rbx), %rdi
leaq -0x30(%rbp), %r13
movq %r13, %rsi
callq 0x2170
movzbl (%r13), %r13d
movq 0x40040(%rbx), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2170
shll $0x10, %r12d
shll $0x8, %r13d
orl %r12d, %r13d
leaq -0x30(%rbp), %rax
movzbl (%rax), %r12d
orl %r13d, %r12d
movq 0x40040(%rbx), %rdi
movq %r15, %rsi
callq 0x2170
movl %r12d, %eax
shll $0x8, %eax
movzbl -0x30(%rbp), %r12d
orl %eax, %r12d
cmpl %r14d, %r12d
je 0x3541
movq 0x40040(%rbx), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rdi,%rax)
je 0x346f
movq 0x40048(%rbx), %r14
movl $0x28, %edi
callq 0x2120
movq %rax, %rbx
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xc92(%rip), %rsi       # 0x4158
leaq 0xca9(%rip), %rdx       # 0x4176
leaq -0x50(%rbp), %rdi
callq 0x2c54
movl $0x80ffee04, (%rbx)     # imm = 0x80FFEE04
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
movb $0x1, %r12b
callq 0x2bb6
movq %rbx, -0x30(%rbp)
movq 0x30(%r14), %rax
movq 0x40(%r14), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x351d
movq %rbx, (%rax)
addq $0x8, 0x30(%r14)
jmp 0x352c
xorl %r12d, %r12d
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x29a4
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3541
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2130
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3572
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x356d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2130
testb %r12b, %r12b
je 0x357f
movl $0x28, %esi
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/JayWalker512[P]JayParser/VM.cpp
// Function: VM::execJMP()
void VM::execJMP()
{
	readNextInstruction();	// Using instruction as buffer for the ID
	
	m_program->seekg(0, std::ios_base::beg);
	
	do {
		if ((unsigned char)m_program->get() == JMPMK)
			if ((unsigned char)m_program->get() == m_instruction)
				return;	// Marker is found
	} while (!m_program->eof());
	
	m_log->add(new Error(FATAL + FILEERR + 3, "Trying to read pass the end of file."));
	m_log->add(new Error(FATAL + PARSERR + 2, "Jump marker not found."));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
callq 0x32ee
movq 0x40040(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2160
movq 0x40040(%r14), %rdi
callq 0x2150
cmpb $0x8, %al
jne 0x35dd
movq 0x40040(%r14), %rdi
callq 0x2150
movzbl %al, %eax
cmpl 0x40028(%r14), %eax
je 0x372f
movq 0x40040(%r14), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rdi,%rax)
je 0x35b8
movq 0x40048(%r14), %r15
movl $0x28, %edi
callq 0x2120
movq %rax, %rbx
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xb8d(%rip), %rsi       # 0x41a3
leaq 0xbaa(%rip), %rdx       # 0x41c7
leaq -0x70(%rbp), %rdi
callq 0x2c54
movl $0x80ffff03, (%rbx)     # imm = 0x80FFFF03
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
addq %rsi, %rdx
movb $0x1, %r13b
callq 0x2bb6
movq %rbx, -0x30(%rbp)
movq 0x30(%r15), %rax
movq 0x40(%r15), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x366d
movq %rbx, (%rax)
addq $0x8, 0x30(%r15)
jmp 0x367c
xorl %r13d, %r13d
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
callq 0x29a4
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x3691
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2130
movq 0x40048(%r14), %r14
movl $0x28, %edi
callq 0x2120
movq %rax, %rbx
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xb14(%rip), %rsi       # 0x41c8
leaq 0xb23(%rip), %rdx       # 0x41de
leaq -0x50(%rbp), %rdi
callq 0x2c54
movl $0x80ffee02, (%rbx)     # imm = 0x80FFEE02
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
movb $0x1, %r12b
callq 0x2bb6
movq %rbx, -0x30(%rbp)
movq 0x30(%r14), %rax
movq 0x40(%r14), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x370b
movq %rbx, (%rax)
addq $0x8, 0x30(%r14)
jmp 0x371a
xorl %r12d, %r12d
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x29a4
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x372f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2130
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3740
movq %rax, %r14
jmp 0x3781
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x375d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2130
testb %r12b, %r12b
jne 0x3781
jmp 0x378e
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x377c
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2130
testb %r13b, %r13b
je 0x378e
movl $0x28, %esi
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/monjar[P]N-Queens-Problem/game.cpp
// Function: Game::initializeRandomlyInEachColumn()
void Game::initializeRandomlyInEachColumn() {
	if ( board->getQueensCount() > board->getColumnsCount() )
		throw "Can't put one queen in each column! Exiting.";
	for ( int i = 0; i < board->getQueensCount(); i++ ) {
		int temp = rand() % board->getRowsCount();
		(*board)[temp][i]->setValue( NQueenBoard::QUEEN_CELL );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x220c
movl (%rax), %r14d
movq (%rbx), %rdi
callq 0x25dc
cmpq %r14, %rax
jb 0x1669
movq (%rbx), %rdi
callq 0x220c
cmpl $0x0, (%rax)
je 0x165a
xorl %r13d, %r13d
leaq -0x2c(%rbp), %r14
leaq 0x1ad4(%rip), %r15      # 0x30e4
callq 0x1030
movslq %eax, %r12
movq (%rbx), %rdi
callq 0x25bc
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movl %edx, -0x2c(%rbp)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x2660
movq (%rax), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
callq 0x2b12
incq %r13
movq (%rbx), %rdi
callq 0x220c
movl (%rax), %eax
cmpq %rax, %r13
jb 0x1610
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x1070
leaq 0x19ad(%rip), %rcx      # 0x3027
movq %rcx, (%rax)
movq 0x494c(%rip), %rsi      # 0x5fd0
movq %rax, %rdi
xorl %edx, %edx
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O3/monjar[P]N-Queens-Problem/game.cpp
// Function: Game::initializeRandomlyInEachRow()
void Game::initializeRandomlyInEachRow() {
	if ( board->getQueensCount() > board->getRowsCount() )
		throw "Can't put one queen in each row! Exiting.";
	for ( int i = 0; i < board->getQueensCount(); i++ ) {
		int temp = rand() % board->getColumnsCount();
		(*board)[i][temp]->setValue( NQueenBoard::QUEEN_CELL );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x220c
movl (%rax), %r14d
movq (%rbx), %rdi
callq 0x25bc
cmpq %r14, %rax
jb 0x1737
movl $0x0, -0x24(%rbp)
movq (%rbx), %rdi
callq 0x220c
cmpl $0x0, (%rax)
je 0x172a
leaq -0x24(%rbp), %r14
leaq 0x1a0d(%rip), %r15      # 0x30e4
callq 0x1030
movslq %eax, %r12
movq (%rbx), %rdi
callq 0x25dc
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r12
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x2660
movq (%rax), %rax
movslq %r12d, %rcx
movq (%rax,%rcx,8), %rdi
movq %r15, %rsi
callq 0x2b12
movl -0x24(%rbp), %r12d
incl %r12d
movl %r12d, -0x24(%rbp)
movq (%rbx), %rdi
callq 0x220c
cmpl (%rax), %r12d
jb 0x16d7
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x1070
leaq 0x190c(%rip), %rcx      # 0x3054
movq %rcx, (%rax)
movq 0x487e(%rip), %rsi      # 0x5fd0
movq %rax, %rdi
xorl %edx, %edx
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O3/monjar[P]N-Queens-Problem/game.cpp
// Function: Game::initializeRandomly()
void Game::initializeRandomly() {
	
	if ( board->getQueensCount() > board->getRowsCount() * board->getColumnsCount() )
		throw "Number of queens is more that number of cells! Exiting.";

	std::vector<Cor> allCells;
	for ( int i = 0; i < board->getRowsCount(); i++ ) 
		for ( int j = 0; j < board->getColumnsCount(); j++ ){
			Cor temp( i, j );
			allCells.push_back( temp );
		}

	std::shuffle( allCells.begin(), allCells.end(), std::default_random_engine( time( NULL ) ) );
	
	for ( int i = 0; i < board->getQueensCount(); i++ )
		(*board)[allCells[i].getY()][allCells[i].getX()]->setValue( NQueenBoard::QUEEN_CELL );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x220c
movl (%rax), %ebx
movq (%r15), %rdi
callq 0x25bc
movq %rax, %r14
movq %r15, -0x38(%rbp)
movq (%r15), %rdi
callq 0x25dc
imulq %r14, %rax
cmpq %rbx, %rax
jb 0x18f8
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
xorl %ebx, %ebx
leaq -0x58(%rbp), %r15
leaq -0x30(%rbp), %r12
leaq -0x2c(%rbp), %r13
movl %ebx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x25bc
movslq %ebx, %rcx
cmpq %rcx, %rax
jbe 0x1816
xorl %ebx, %ebx
movl %ebx, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x25dc
movslq %ebx, %rcx
cmpq %rcx, %rax
jbe 0x180f
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2b20
movq %r14, %rdi
movq %r15, %rsi
callq 0x1962
movl -0x2c(%rbp), %ebx
incl %ebx
jmp 0x17d8
movl -0x30(%rbp), %ebx
incl %ebx
jmp 0x17bf
movq -0x50(%rbp), %r14
movq -0x48(%rbp), %r15
xorl %edi, %edi
callq 0x10c0
movq %rax, %rcx
movabsq $0x200000005, %rdx      # imm = 0x200000005
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
subq %rdx, %rax
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
adcq %rcx, %rax
leaq -0x58(%rbp), %rdx
movq %rax, (%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x199d
xorl %r12d, %r12d
leaq 0x186e(%rip), %r14      # 0x30e4
xorl %r13d, %r13d
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x220c
movl (%rax), %eax
cmpq %rax, %r13
jae 0x18d4
movq -0x38(%rbp), %rax
movq (%rax), %r15
movq -0x50(%rbp), %rdi
addq %r12, %rdi
callq 0x2b68
movq %r15, %rdi
movq %rax, %rsi
callq 0x2660
movq %rax, %r15
movq -0x50(%rbp), %rdi
addq %r12, %rdi
callq 0x2b5e
movslq (%rax), %rax
movq (%r15), %rcx
movq (%rcx,%rax,8), %rdi
movq %r14, %rsi
callq 0x2b12
incq %r13
addq $0x8, %r12
jmp 0x1879
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x18e9
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x10f0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x1070
leaq 0x1775(%rip), %rcx      # 0x307e
movq %rcx, (%rax)
movq 0x46bd(%rip), %rsi      # 0x5fd0
movq %rax, %rdi
xorl %edx, %edx
callq 0x1150
jmp 0x1925
jmp 0x1925
jmp 0x1925
jmp 0x1925
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x193d
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O3/monjar[P]N-Queens-Problem/nqueenboard.cpp
// Function: NQueenBoard::getCellsMatchingValue(int const&)
std::vector<Cor> NQueenBoard::getCellsMatchingValue( const int &value ) {

    std::vector<Cor> returnValue;

    for ( unsigned int i = 0; i < this->getRowsCount(); i++ ) {

        for ( unsigned int j = 0; j < this->getColumnsCount(); j++ ) {

            Cell currentCell = *( this->cells[i].at(j) );
            if ( currentCell.getValue() == value )
                returnValue.push_back( Cor( i, j ) );

        }
        
    }

    return returnValue;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x38(%rbp)
movq $0x0, 0x10(%rdi)
movl $0x0, -0x2c(%rbp)
leaq -0x50(%rbp), %r12
movq %r15, %rdi
callq 0x25bc
movl -0x2c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x2182
xorl %r13d, %r13d
leaq (%rcx,%rcx,2), %rbx
movq %rbx, -0x48(%rbp)
movq %r15, %rdi
callq 0x25dc
movl %r13d, %esi
cmpq %rsi, %rax
jbe 0x217a
movq (%r15), %rcx
movq (%rcx,%rbx,8), %rax
movq 0x8(%rcx,%rbx,8), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x2195
movq (%rax,%rsi,8), %rsi
movq %r12, %rdi
callq 0x2ad0
movq %r12, %rdi
callq 0x2af6
movl (%rax), %eax
cmpl (%r14), %eax
jne 0x216a
movq %r15, %rbx
movq %r12, %r15
movq %r14, %r12
movl -0x2c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl %r13d, -0x3c(%rbp)
leaq -0x58(%rbp), %r14
movq %r14, %rdi
leaq -0x40(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x2b20
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2216
movq %r12, %r14
movq %r15, %r12
movq %rbx, %r15
movq -0x48(%rbp), %rbx
movq %r12, %rdi
callq 0x2b00
incl %r13d
jmp 0x20df
incl -0x2c(%rbp)
jmp 0x20c0
movq -0x38(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf4c(%rip), %rdi       # 0x30e8
xorl %eax, %eax
callq 0x1110
jmp 0x21b9
jmp 0x21b9
jmp 0x21a9
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2b00
jmp 0x21bc
jmp 0x21b9
movq %rax, %r14
movq -0x38(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x21d4
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/monjar[P]N-Queens-Problem/board.cpp
// Function: Board::Board(unsigned int const&, unsigned int const&, int const&)
Board::Board( const unsigned int &row, const unsigned int &column, const int &defaultValue ) { 
	
	cells.resize( row );
	for ( int i = 0; i < row; i++ )
		cells[i].resize( column );

	for ( int i = 0; i < row; i++ ) 
		for ( int j = 0; j < column; j++ )
			cells[i][j] = new Cell( defaultValue );
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl (%rsi), %esi
movq %rdi, -0x30(%rbp)
callq 0x26a2
movq %rbx, -0x38(%rbp)
cmpl $0x0, (%rbx)
je 0x242b
xorl %ebx, %ebx
xorl %r12d, %r12d
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq %rbx, %rdi
movl (%r15), %esi
callq 0x26e6
incq %r12
movq -0x38(%rbp), %rax
movl (%rax), %eax
addq $0x18, %rbx
cmpq %rax, %r12
jb 0x23a5
testl %eax, %eax
je 0x242b
movl (%r15), %ecx
xorl %esi, %esi
testl %ecx, %ecx
movl $0x0, %ecx
je 0x2421
movq %rsi, -0x40(%rbp)
leaq (%rsi,%rsi,2), %r12
xorl %ebx, %ebx
movl $0x8, %edi
callq 0x10e0
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0x2aac
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax,%r12,8), %rax
movq %r13, (%rax,%rbx,8)
incq %rbx
movl (%r15), %ecx
cmpq %rcx, %rbx
jb 0x23e5
movq -0x38(%rbp), %rax
movl (%rax), %eax
movq -0x40(%rbp), %rsi
incq %rsi
movl %eax, %edx
cmpq %rdx, %rsi
jb 0x23d2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x243e
jmp 0x243e
movq %rax, %r14
jmp 0x2453
movq %rax, %r14
movl $0x8, %esi
movq %r13, %rdi
callq 0x10f0
movq -0x30(%rbp), %rdi
callq 0x1b7c
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/monjar[P]N-Queens-Problem/board.cpp
// Function: Board::Board(Board const&)
Board::Board( const Board &board ) {
	this->cells.resize( board.getRowsCount() );
	for ( int i = 0; i < board.getRowsCount(); i++ ) {
		this->cells[i].resize( board.getColumnsCount() );
		for ( int j = 0; j < board.getColumnsCount(); j++ ) 
			this->cells[i][j]->setValue( board.getCell(i, j).getValue() );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
movq %rdi, -0x38(%rbp)
callq 0x26a2
movl $0x0, -0x30(%rbp)
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x2586
movq (%rax), %rcx
xorl %edi, %edi
leaq -0x48(%rbp), %r15
movq %rdi, -0x40(%rbp)
leaq (%rdi,%rdi,2), %r13
leaq (,%r13,8), %rdi
movq -0x38(%rbp), %rdx
addq (%rdx), %rdi
movq 0x8(%rax), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
callq 0x26e6
movl $0x0, -0x2c(%rbp)
movq (%r14), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x255a
xorl %ebx, %ebx
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%rbx,8), %r12
movq %r15, %rdi
movq %r14, %rsi
leaq -0x30(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
callq 0x25f0
movq %r15, %rdi
callq 0x2af6
movq %r12, %rdi
movq %rax, %rsi
callq 0x2b12
movq %r15, %rdi
callq 0x2b00
incq %rbx
movl %ebx, -0x2c(%rbp)
movq (%r14), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rbx, %rdx
ja 0x2501
movq -0x40(%rbp), %rdi
incq %rdi
movl %edi, -0x30(%rbp)
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
cmpq %rdi, %rdx
ja 0x24c5
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2599
jmp 0x2599
movq %rax, %r14
jmp 0x25aa
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2b00
movq -0x38(%rbp), %rdi
callq 0x1b7c
movq %r14, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: branching_factor(problem_t const&, unsigned int)
inline std::pair<float, float> branching_factor(const problem_t &problem, unsigned nsamples) {
  Online::Policy::random_t<state_t> random_policy(problem);
    for( unsigned i = 0; i < nsamples; ++i ) {
        state_t s = problem.init();
        while( !problem.terminal(s) ) {
            Problem::action_t a = random_policy(s);
            if( a == Problem::noop ) break;
            std::pair<state_t, bool> p = problem.sample(s, a);
            s = p.first;
        }
    }
    float avg = problem.avg_branching_;
    float max = problem.max_branching_;
    return std::make_pair(avg, max);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movq %rdi, 0x10(%rsp)
movl 0x35ce4(%rip), %eax     # 0x3d2c0
movl %eax, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rsp)
leaq 0x34969(%rip), %rax     # 0x3bf58
movq %rax, 0x8(%rsp)
movl %esi, 0x4(%rsp)
testl %esi, %esi
je 0x76db
leaq 0x34(%rsp), %r13
leaq 0x30(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0xa0(%rsp), %r12
xorl %ebp, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movups %xmm0, 0x10(%r13)
movups %xmm0, 0x20(%r13)
movups %xmm0, 0x30(%r13)
xorl %ecx, %ecx
movq %rcx, 0x40(%r13)
movb $0x1, 0x8c(%rsp)
movq %rcx, 0x90(%rsp)
movq %r14, %rdi
movq %rax, %rsi
callq 0xc30a
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
jne 0x76b3
movq %r15, %rdi
movq %r14, %rsi
callq 0xcd56
cmpl $-0x1, %eax
je 0x76b3
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %eax, %ecx
callq 0xcea2
movq %r14, %rdi
movq %r12, %rsi
callq 0xc30a
cmpb $0x0, 0xfc(%rsp)
jne 0x765a
movq 0x100(%rsp), %rdi
testq %rdi, %rdi
je 0x765a
callq 0x5340
jmp 0x765a
cmpb $0x0, 0x8c(%rsp)
jne 0x76cf
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x76cf
callq 0x5340
incl %ebp
cmpl 0x4(%rsp), %ebp
jne 0x7619
xorps %xmm0, %xmm0
cvtsi2ssl 0x98(%rbx), %xmm0
movups 0x9c(%rbx), %xmm1
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[2,3]
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x772b
movq %rax, %rbx
cmpb $0x0, 0xfc(%rsp)
jne 0x772e
movq 0x100(%rsp), %rdi
testq %rdi, %rdi
je 0x772e
callq 0x5340
jmp 0x772e
jmp 0x772b
movq %rax, %rbx
cmpb $0x0, 0x8c(%rsp)
jne 0x774a
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x774a
callq 0x5340
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/dispatcher.h
// Function: Dispatcher::dispatcher_t<state_t>::~dispatcher_t()
virtual ~dispatcher_t() {
        for( typename std::map<std::string, Algorithm::algorithm_t<T>*>::const_iterator it = algorithms_.begin(); it != algorithms_.end(); ++it )
            delete it->second;
        for( typename std::map<std::string, Heuristic::heuristic_t<T>*>::const_iterator it = heuristics_.begin(); it != heuristics_.end(); ++it )
            delete it->second;
        for( typename std::map<std::string, Online::Policy::policy_t<T>*>::const_iterator it = policies_.begin(); it != policies_.end(); ++it )
            delete it->second;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x325ed(%rip), %rax     # 0x3c100
movq %rax, (%rdi)
movq 0x20(%rdi), %r14
leaq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x9b42
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x9b32
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x52f0
movq %rax, %r14
cmpq %r15, %rax
jne 0x9b23
movq 0x50(%rbx), %r14
leaq 0x40(%rbx), %r15
cmpq %r15, %r14
je 0x9b6e
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x9b5e
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x52f0
movq %rax, %r14
cmpq %r15, %rax
jne 0x9b4f
movq 0x80(%rbx), %r14
leaq 0x70(%rbx), %r15
cmpq %r15, %r14
je 0x9b9d
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x9b8d
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x52f0
movq %rax, %r14
cmpq %r15, %rax
jne 0x9b7e
leaq 0x68(%rbx), %rdi
leaq 0x38(%rbx), %r14
addq $0x8, %rbx
callq 0xda02
movq %r14, %rdi
callq 0xda7e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xdafa
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: shortest_path_cache_t::initialize(int, unsigned int)
void initialize(int num_nodes, unsigned capacity) {
        num_nodes_ = num_nodes;
        capacity_ = capacity;
        distances_ = new int[num_nodes_];
        items_ = new shortest_path_cache_item_t*[num_nodes_];
        for( int i = 0; i < num_nodes_; ++i )
            items_[i] = new shortest_path_cache_item_t;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x18(%rdi)
movslq %esi, %r15
leaq (,%r15,4), %rdi
testl %r15d, %r15d
movq $-0x1, %rax
cmovsq %rax, %rdi
leaq (,%r15,8), %r14
cmovsq %rax, %r14
callq 0x5030
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x5030
movq %rax, 0x10(%rbx)
testl %r15d, %r15d
jle 0xa6d9
movl %ebp, %r14d
xorl %r15d, %r15d
movl $0x38, %edi
callq 0x5290
leaq 0x30(%rax), %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0xa69e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: next_cache_t::initialize(int, unsigned int)
void initialize(int num_actions, unsigned capacity) {
        num_actions_ = num_actions;
        capacity_ = capacity;
        items_ = new next_cache_item_t*[num_actions_];
        for( int i = 0; i < num_actions_; ++i )
            items_[i] = new next_cache_item_t;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x10(%rdi)
movl %esi, %r14d
leaq (,%r14,8), %rax
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x5030
movq %rax, 0x8(%rbx)
testl %ebp, %ebp
jle 0xa758
xorl %r15d, %r15d
movl $0x38, %edi
callq 0x5290
leaq 0x30(%rax), %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0xa71d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_t::preprocess() const
void preprocess() const {
        if( distances_ == 0 ) {
            assert(shared_);
            std::pair<bool, const int*> p(false, 0);
            if( use_cache_ ) p = cache_.lookup(*graph_, current_, info_);
            if( p.first ) {
                if( !shared_ ) delete[] distances_;
                distances_ = const_cast<int*>(p.second);
                shared_ = true;
            } else {
                if( shared_ ) distances_ = new int[num_nodes_];
                assert(distances_ != 0);
                shared_ = false;
                if( p.second ) {
                    memcpy(const_cast<int*>(distances_), p.second, num_nodes_ * sizeof(int));
                } else {
                    graph_->dijkstra(current_, distances_, info_.known_, info_.blocked_, false);
                    //distances_[current_] = graph_->bfs(current_, num_nodes_ - 1, info_.known_, info_.blocked_, true);
                }
            }
            //heuristic_ = distances_[current_];
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x60(%rdi)
je 0xb485
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rbx
movb 0x5c(%rdi), %cl
testb %cl, %cl
je 0xb561
cmpb $0x1, 0x31e1e(%rip)     # 0x3d2b8
jne 0xb4dc
movq 0x31dd5(%rip), %rsi     # 0x3d278
movl (%rbx), %edx
leaq 0x4(%rbx), %rcx
leaq 0x31de0(%rip), %rdi     # 0x3d290
callq 0xb5a0
movq %rdx, %r14
movb 0x5c(%rbx), %cl
testb $0x1, %al
je 0xb4df
testb $0x1, %cl
jne 0xb4d2
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xb4d2
callq 0x5340
movq %r14, 0x60(%rbx)
movb $0x1, 0x5c(%rbx)
jmp 0xb47d
xorl %r14d, %r14d
testb $0x1, %cl
je 0xb50c
movslq 0x31d95(%rip), %rax     # 0x3d280
leaq (,%rax,4), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x5030
movq %rax, 0x60(%rbx)
jmp 0xb515
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0xb580
movb $0x0, 0x5c(%rbx)
testq %r14, %r14
je 0xb53b
movslq 0x31d5b(%rip), %rdx     # 0x3d280
shlq $0x2, %rdx
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5230
movq 0x31d36(%rip), %rdi     # 0x3d278
movl (%rbx), %esi
leaq 0x4(%rbx), %rcx
addq $0x28, %rbx
movq %rax, %rdx
movq %rbx, %r8
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb6d4
leaq 0x1ff7a(%rip), %rdi     # 0x2b4e2
leaq 0x1ff7b(%rip), %rsi     # 0x2b4ea
leaq 0x1ff7d(%rip), %rcx     # 0x2b4f3
movl $0x160, %edx            # imm = 0x160
callq 0x51c0
leaq 0x20019(%rip), %rdi     # 0x2b5a0
leaq 0x1ff5c(%rip), %rsi     # 0x2b4ea
leaq 0x1ff5e(%rip), %rcx     # 0x2b4f3
movl $0x169, %edx            # imm = 0x169
callq 0x51c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: shortest_path_cache_t::lookup(CTP::graph_t const&, int, state_info_t const&)
std::pair<bool, const int*> lookup(const CTP::graph_t &graph, int source, const state_info_t &info) {
        ++lookups_;
        shortest_path_cache_item_t *item = items_[source];
        shortest_path_cache_item_t::const_iterator it = item->find(info);
        if( it != item->end() ) {
            ++hits_;
            return std::make_pair(true, it->second);
        } else {
            if( size_ < capacity_ ) {
                ++size_;
                int *distances = new int[num_nodes_];
                graph.dijkstra(source, distances, info.known_, info.blocked_, false);
                distances[source] = graph.bfs(source, num_nodes_ - 1, info.known_, info.blocked_, true);
                item->insert(std::make_pair(info, distances));
                return std::make_pair(true, distances);
            } else {
                graph.dijkstra(source, distances_, info.known_, info.blocked_, false);
                distances_[source] = graph.bfs(source, num_nodes_ - 1, info.known_, info.blocked_, true);
                return std::make_pair(false, distances_);
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdi, %r15
incl 0x20(%rdi)
movq %rsi, %r12
movq 0x10(%rdi), %rax
movslq %edx, %r14
movq (%rax,%r14,8), %r13
movq %r13, %rdi
movq %rcx, %rsi
callq 0xb85a
testq %rax, %rax
je 0xb5e2
incl 0x24(%r15)
movq 0x50(%rax), %rbp
jmp 0xb676
movl 0x1c(%r15), %eax
cmpl 0x18(%r15), %eax
jae 0xb68e
incl %eax
movl %eax, 0x1c(%r15)
movslq (%r15), %rax
leaq (,%rax,4), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x5030
movq %rax, %rbp
leaq 0x24(%rbx), %r8
movq %r8, (%rsp)
movq %r12, %rdi
movl %r14d, %esi
movq %rax, %rdx
movq %rbx, %rcx
xorl %r9d, %r9d
callq 0xb6d4
movl (%r15), %edx
decl %edx
movq %r12, %rdi
movl %r14d, %esi
movq %rbx, %rcx
movq (%rsp), %r8
movl $0x1, %r9d
callq 0xae5a
movl %eax, (%rbp,%r14,4)
leaq 0x8(%rsp), %rax
movl $0x12, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsl (%rsi), %es:(%rdi)
movq %rbp, 0x48(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0xb980
movb $0x1, %r13b
movl %r13d, %eax
movq %rbp, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rdx
leaq 0x24(%rbx), %rbp
xorl %r13d, %r13d
movq %r12, %rdi
movl %r14d, %esi
movq %rbx, %rcx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0xb6d4
movl (%r15), %edx
decl %edx
movq %r12, %rdi
movl %r14d, %esi
movq %rbx, %rcx
movq %rbp, %r8
movl $0x1, %r9d
callq 0xae5a
movq 0x8(%r15), %rbp
movl %eax, (%rbp,%r14,4)
jmp 0xb679
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: next_cache_t::lookup(state_t const&, int) const
const std::vector<std::pair<state_t, float> >* lookup(const state_t &state,
                                                          Problem::action_t a) const {
        ++lookups_;
        next_cache_item_t *item = items_[a];
        next_cache_item_t::const_iterator it = item->find(state);
        if( it != item->end() ) {
            ++hits_;
            return it->second;
        } else
            return 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
incl 0x18(%rdi)
movq 0x8(%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0xc072
testq %rax, %rax
je 0xbc7d
incl 0x1c(%rbx)
movq 0x78(%rax), %rax
jmp 0xbc7f
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: next_cache_t::insert(state_t const&, int, std::vector<std::pair<state_t, float>, std::allocator<std::pair<state_t, float>>>&)
void insert(const state_t &state,
                Problem::action_t a,
                std::vector<std::pair<state_t, float> > &next) {
        if( size_ < capacity_ ) {
            ++size_;
            next_cache_item_t *item = items_[a];
            std::vector<std::pair<state_t, float> > *ptr
              = new std::vector<std::pair<state_t, float> >(next);
            item->insert(std::make_pair(state, ptr));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl 0x14(%rdi), %eax
cmpl 0x10(%rdi), %eax
jae 0xc038
movq %rcx, %r12
movq %rsi, %rbx
incl %eax
movl %eax, 0x14(%rdi)
movq 0x8(%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r14
movl $0x18, %edi
callq 0x5290
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xc8e8
xorps %xmm0, %xmm0
movq %rsp, %r12
movups %xmm0, 0x34(%r12)
movups %xmm0, 0x24(%r12)
movups %xmm0, 0x14(%r12)
movups %xmm0, 0x4(%r12)
xorl %eax, %eax
movq %rax, 0x44(%r12)
movb $0x1, 0x5c(%r12)
movq %rax, 0x60(%r12)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xc30a
movq %r15, 0x70(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0xc97a
cmpb $0x0, 0x5c(%rsp)
jne 0xc038
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xc038
callq 0x5340
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpb $0x0, 0x5c(%rsp)
jne 0xc06a
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xc06a
callq 0x5340
jmp 0xc06a
movq %rax, %rbx
movq %r15, %rdi
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_t::operator=(state_t const&)
const state_t& operator=(const state_t &s) {
        current_ = s.current_;
        info_ = s.info_;
        memcpy(visited_, s.visited_, words_for_nodes_ * sizeof(unsigned));
        if( s.shared_ ) {
            if( !shared_ ) delete[] distances_;
            distances_ = s.distances_;
            shared_ = true;
        } else {
            if( shared_ ) {
                distances_ = new int[num_nodes_];
                shared_ = false;
            }
            assert(distances_ != 0);
            memcpy(const_cast<int*>(distances_), s.distances_, num_nodes_ * sizeof(int));
        }
        heuristic_ = s.heuristic_;
        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
addq $0x4, %rsi
addq $0x4, %rdi
movslq 0x30f4c(%rip), %r15     # 0x3d274
shlq $0x2, %r15
movq %r15, %rdx
callq 0x5230
leaq 0x28(%rbx), %rdi
leaq 0x28(%r14), %rsi
movq %r15, %rdx
callq 0x5230
leaq 0x4c(%rbx), %rdi
leaq 0x4c(%r14), %rsi
movslq 0x30f35(%rip), %rdx     # 0x3d288
shlq $0x2, %rdx
callq 0x5230
movb 0x5c(%rbx), %al
cmpb $0x1, 0x5c(%r14)
jne 0xc386
testb %al, %al
jne 0xc378
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xc378
callq 0x5340
movq 0x60(%r14), %rax
movq %rax, 0x60(%rbx)
movb $0x1, 0x5c(%rbx)
jmp 0xc3d6
testb %al, %al
je 0xc3b9
movslq 0x30eef(%rip), %rax     # 0x3d280
leaq (,%rax,4), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x5030
movq %rax, %rdi
movq %rax, 0x60(%rbx)
movb $0x0, 0x5c(%rbx)
jmp 0xc3c2
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xc3e6
movq 0x60(%r14), %rsi
movslq 0x30eb3(%rip), %rdx     # 0x3d280
shlq $0x2, %rdx
callq 0x5230
movl 0x68(%r14), %eax
movl %eax, 0x68(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1f1b3(%rip), %rdi     # 0x2b5a0
leaq 0x1f0f6(%rip), %rsi     # 0x2b4ea
leaq 0x1f1b5(%rip), %rcx     # 0x2b5b0
movl $0x18f, %edx            # imm = 0x18F
callq 0x51c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_t::clear()
void clear() {
        current_ = 0;
        info_.clear();
        memset(visited_, 0, words_for_nodes_ * sizeof(unsigned));
        if( !shared_ ) {
            delete[] distances_;
            shared_ = true;
        }
        distances_ = 0;
        heuristic_ = -1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, (%rdi)
addq $0x4, %rdi
movslq 0x30580(%rip), %r14     # 0x3d274
shlq $0x2, %r14
xorl %esi, %esi
movq %r14, %rdx
callq 0x5180
leaq 0x28(%rbx), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x5180
leaq 0x4c(%rbx), %rdi
movslq 0x3056d(%rip), %rdx     # 0x3d288
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x5180
cmpb $0x0, 0x5c(%rbx)
jne 0xcd3e
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xcd3a
callq 0x5340
movb $0x1, 0x5c(%rbx)
movq $0x0, 0x60(%rbx)
movl $0xffffffff, 0x68(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop