LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x58(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x5c(%rdi)
callq 0x5e50
jmp 0x6209
jmp 0x627c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x62a0
movq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2130
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x6520
movq -0x40(%rbp), %rdi
callq 0x2070
movq 0x8da4(%rip), %rdi      # 0xeff0
leaq 0x3e48(%rip), %rsi      # 0xa09b
callq 0x20e0
movq %rax, -0x38(%rbp)
jmp 0x625e
movq -0x38(%rbp), %rdi
movl $0xa, %esi
callq 0x2120
jmp 0x626e
leaq -0x30(%rbp), %rdi
callq 0x21f8
callq 0x2180
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x21f8
callq 0x2180
jmp 0x629e
jmp 0x62a0
movq -0x18(%rbp), %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x3370
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x62f1
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x67e0
jmp 0x6372
cmpl $-0x2, -0xc(%rbp)
jne 0x630b
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl $0x1, %esi
callq 0x67e0
jmp 0x6370
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x6620
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x634d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
callq 0x62c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6312
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x6620
cmpl $0x0, (%rax)
je 0x636e
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x2, %esi
callq 0x62c0
jmp 0x6370
jmp 0x6372
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x30, %rdi
callq 0x2ed0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x63fb
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0x6700
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2fb0
movzbl %al, %esi
andl $0x1, %esi
movq 0x8bd5(%rip), %rdi      # 0xefc0
callq 0x21d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x639b
movq 0x8bbe(%rip), %rdi      # 0xefc0
movl $0xa, %esi
callq 0x2120
movq 0x8bad(%rip), %rdi      # 0xefc0
leaq 0x3cb6(%rip), %rsi      # 0xa0d0
callq 0x20e0
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x30, %rdi
callq 0x2ed0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x2040
movq %rax, %rdi
movl $0xa, %esi
callq 0x2120
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3190
movl $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x58(%rcx), %eax
jge 0x64f5
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movslq -0x18(%rbp), %rsi
callq 0x2f50
movq %rdx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
jmp 0x64aa
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2fb0
movq -0x50(%rbp), %rdi
movzbl %al, %esi
callq 0x67e0
jmp 0x64d1
jmp 0x64d3
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6483
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x2fe0
jmp 0x6512
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6508
movq -0x50(%rbp), %rdi
callq 0x2fe0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x21c0
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/occurs.cc
// Function: main
int main()
{
	// currVal is the number we're counting; we'll read new values into val
	int currVal = 0, val = 0;

	// read first number and ensure that we have data to process
	if (std::cin >> currVal) {        
		int cnt = 1;  // store the count for the current value we're processing
		while (std::cin >> val) { // read the remaining numbers 
			if (val == currVal)   // if the values are the same
				++cnt;            // add 1 to cnt 
			else { // otherwise, print the count for the previous value
				std::cout << currVal << " occurs " 
				          << cnt << " times" << std::endl;
				currVal = val;    // remember the new value
				cnt = 1;          // reset the counter
			}
		}  // while loop ends here
		// remember to print the count for the last value in the file
		std::cout << currVal << " occurs " 
		          << cnt << " times" << std::endl;
	} // outermost if statement ends here
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq 0x2ddc(%rip), %rdi      # 0x3fe0
leaq -0x8(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1070
testb $0x1, %al
jne 0x1225
jmp 0x1304
movl $0x1, -0x10(%rbp)
movq 0x2dad(%rip), %rdi      # 0x3fe0
leaq -0xc(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1070
testb $0x1, %al
jne 0x1251
jmp 0x12bd
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x1264
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12b8
movl -0x8(%rbp), %esi
movq 0x2d62(%rip), %rdi      # 0x3fd0
callq 0x1090
movq %rax, %rdi
leaq 0xd87(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x1090
movq %rax, %rdi
leaq 0xd76(%rip), %rsi       # 0x200d
callq 0x1050
movq %rax, %rdi
movq 0x2d1a(%rip), %rsi      # 0x3fc0
callq 0x1060
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x1, -0x10(%rbp)
jmp 0x122c
movl -0x8(%rbp), %esi
movq 0x2d09(%rip), %rdi      # 0x3fd0
callq 0x1090
movq %rax, %rdi
leaq 0xd2e(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x1090
movq %rax, %rdi
leaq 0xd1d(%rip), %rsi       # 0x200d
callq 0x1050
movq %rax, %rdi
movq 0x2cc1(%rip), %rsi      # 0x3fc0
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: JayWalker512[P]JayParser/VM.cpp
// Function: VM::VM(std::basic_ifstream<char, std::char_traits<char>>*)
VM::VM(std::ifstream *file) : m_ic(0), m_opc(0), m_op1(0), m_op2(0), m_program(file)
{
	m_log = Log::init();
	
	for (uint i = 0; i < 0xFFFF; ++i)
		m_memory[i] = 0;
	
	m_eax = m_memory + EAX;
	m_ebx = m_memory + EBX;
	m_ecx = m_memory + ECX;
	m_edx = m_memory + EDX;
	
	m_lgf = m_memory + LGF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, 0x40020(%rax)
movl $0x0, 0x40024(%rax)
movl $0x0, 0x4002c(%rax)
movl $0x0, 0x40030(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x40040(%rax)
callq 0x2770
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40048(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
jae 0x40c7
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl $0x0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x40a5
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x3fffc, %rcx          # imm = 0x3FFFC
movq %rcx, 0x40000(%rax)
movq %rax, %rcx
addq $0x3fff8, %rcx          # imm = 0x3FFF8
movq %rcx, 0x40008(%rax)
movq %rax, %rcx
addq $0x3fff4, %rcx          # imm = 0x3FFF4
movq %rcx, 0x40010(%rax)
movq %rax, %rcx
addq $0x3fff0, %rcx          # imm = 0x3FFF0
movq %rcx, 0x40018(%rax)
movq %rax, %rcx
addq $0x3ffc0, %rcx          # imm = 0x3FFC0
movq %rcx, 0x40038(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JayWalker512[P]JayParser/VM.cpp
// Function: VM::parse()
void VM::parse()
{
	parseDataSection();
	
	if (m_log->getErrorCount())
		return;

	parseCodeSection();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x4180
movq -0x10(%rbp), %rax
movq 0x40048(%rax), %rdi
callq 0x4ad0
cmpl $0x0, %eax
je 0x4170
jmp 0x4179
movq -0x10(%rbp), %rdi
callq 0x4300
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0xddffddff, %esi       # imm = 0xDDFFDDFF
callq 0x4720
movq -0x50(%rbp), %rax
movq 0x40040(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x22b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x41bd
jmp 0x422f
movq -0x50(%rbp), %rdi
callq 0x4b20
movq -0x50(%rbp), %rcx
movl 0x4002c(%rcx), %eax
shll $0x10, %eax
addl 0x40030(%rcx), %eax
cmpl $0xccffccff, %eax       # imm = 0xCCFFCCFF
jne 0x41e5
jmp 0x42ac
movl $0x0, -0xc(%rbp)
movq -0x50(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4002c(%rcx), %eax
jae 0x422a
movq -0x50(%rbp), %rax
movq 0x40040(%rax), %rdi
callq 0x21c0
movl %eax, %edx
movq -0x50(%rbp), %rax
movl 0x40030(%rax), %ecx
addl -0xc(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x41ec
jmp 0x419e
movq -0x50(%rbp), %rax
movq 0x40048(%rax), %rax
movq %rax, -0x68(%rbp)
movl $0x28, %edi
callq 0x2150
movq %rax, -0x60(%rbp)
movb $0x1, -0x45(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2280
movq -0x58(%rbp), %rdx
leaq 0xf0f(%rip), %rsi       # 0x5177
leaq -0x30(%rbp), %rdi
callq 0x2820
jmp 0x4273
movq -0x60(%rbp), %rdi
movl $0x80ffee05, %esi       # imm = 0x80FFEE05
leaq -0x30(%rbp), %rdx
callq 0x28d0
jmp 0x4287
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
callq 0x27f0
jmp 0x429a
leaq -0x30(%rbp), %rdi
callq 0x20c0
leaq -0x31(%rbp), %rdi
callq 0x2190
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x42d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20c0
leaq -0x31(%rbp), %rdi
callq 0x2190
testb $0x1, -0x45(%rbp)
jne 0x42e6
jmp 0x42f4
movq -0x60(%rbp), %rdi
movl $0x28, %esi
callq 0x2160
jmp 0x42f6
movq -0x40(%rbp), %rdi
callq 0x2270
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x40040(%rax), %rdi
leaq -0x9(%rbp), %rsi
callq 0x2200
movq -0x18(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movl %ecx, 0x40028(%rax)
movl 0x40020(%rax), %ecx
incl %ecx
movl %ecx, 0x40020(%rax)
movl 0x40028(%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
jb 0x4662
jmp 0x4600
movl -0x10(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x466f
jmp 0x460d
movl -0x10(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0x4662
jmp 0x461a
movl -0x10(%rbp), %eax
addl $-0x8, %eax
subl $0x2, %eax
jb 0x4662
jmp 0x4627
movl -0x10(%rbp), %eax
addl $-0x10, %eax
subl $0x4, %eax
jb 0x466f
jmp 0x4634
movl -0x10(%rbp), %eax
addl $-0x14, %eax
subl $0x2, %eax
jb 0x4664
jmp 0x4641
movl -0x10(%rbp), %eax
subl $0x19, %eax
je 0x4664
jmp 0x464b
movl -0x10(%rbp), %eax
addl $-0x20, %eax
subl $0x4, %eax
jb 0x466f
jmp 0x4658
movl -0x10(%rbp), %eax
subl $0x29, %eax
jne 0x4678
jmp 0x4662
jmp 0x4678
movq -0x18(%rbp), %rdi
callq 0x4af0
jmp 0x4678
movq -0x18(%rbp), %rdi
callq 0x4b20
addq $0x20, %rsp
popq %rbp
retq
nop
// File: JayWalker512[P]JayParser/VM.cpp
// Function: VM::readNextOperator(unsigned int&)
void VM::readNextOperator(uint& op)
{
	char high, low;
	m_program->get(high);
	m_program->get(low);
	
	op = ((unsigned char)high << 8) + (unsigned char)low;
	
	++m_opc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x40040(%rax), %rdi
leaq -0x11(%rbp), %rsi
callq 0x2200
movq -0x20(%rbp), %rax
movq 0x40040(%rax), %rdi
leaq -0x12(%rbp), %rsi
callq 0x2200
movq -0x20(%rbp), %rax
movzbl -0x11(%rbp), %edx
shll $0x8, %edx
movzbl -0x12(%rbp), %ecx
addl %ecx, %edx
movq -0x10(%rbp), %rcx
movl %edx, (%rcx)
movl 0x40024(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40024(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x10(%rbp)
movq 0x40040(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x21f0
movq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4570
movq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4570
movq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4570
movq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4570
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x4791
jmp 0x482d
jmp 0x4793
movq -0x50(%rbp), %rax
movq 0x40040(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x22b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4777
movq -0x50(%rbp), %rax
movq 0x40048(%rax), %rax
movq %rax, -0x68(%rbp)
movl $0x28, %edi
callq 0x2150
movq %rax, -0x60(%rbp)
movb $0x1, -0x45(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2280
movq -0x58(%rbp), %rdx
leaq 0x96f(%rip), %rsi       # 0x5158
leaq -0x30(%rbp), %rdi
callq 0x2820
jmp 0x47f4
movq -0x60(%rbp), %rdi
movl $0x80ffee04, %esi       # imm = 0x80FFEE04
leaq -0x30(%rbp), %rdx
callq 0x28d0
jmp 0x4808
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
callq 0x27f0
jmp 0x481b
leaq -0x30(%rbp), %rdi
callq 0x20c0
leaq -0x31(%rbp), %rdi
callq 0x2190
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4856
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20c0
leaq -0x31(%rbp), %rdi
callq 0x2190
testb $0x1, -0x45(%rbp)
jne 0x4867
jmp 0x4875
movq -0x60(%rbp), %rdi
movl $0x28, %esi
callq 0x2160
jmp 0x4877
movq -0x40(%rbp), %rdi
callq 0x2270
// File: JayWalker512[P]JayParser/./VM.h
// Function: VM::execJMF()
inline void execJMF() {
		if (*m_lgf != 0)
			execJMP();
		else
			skipNextInstruction();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x40038(%rax), %rax
cmpl $0x0, (%rax)
je 0x4bfb
movq -0x10(%rbp), %rdi
callq 0x4880
jmp 0x4c04
movq -0x10(%rbp), %rdi
callq 0x4680
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: monjar[P]N-Queens-Problem/main.cpp
// Function: main
int main () {

	Game *game = new Game( 8 );
	game->initializeRandomly();

	// delete game; 

	SolveMethod *method = new HillClimbingMethod;
	Solver *solver = new Solver( method );
	solver->solve( game );

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl $0x8, %edi
callq 0x10e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl $0x8, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x15e0
jmp 0x1465
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18e0
movl $0x8, %edi
movq %rdi, -0x50(%rbp)
callq 0x10e0
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
callq 0x1520
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x10e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rsi
callq 0x1580
jmp 0x14b6
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15a0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x8, %esi
callq 0x10f0
jmp 0x1509
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x8, %esi
callq 0x10f0
movq -0x20(%rbp), %rdi
callq 0x1160
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
callq 0x3a10
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x44e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jbe 0x1764
movl $0x8, %edi
callq 0x1070
movq %rax, %rdi
leaq 0x58d6(%rip), %rax      # 0x7027
movq %rax, (%rdi)
movq 0xa875(%rip), %rsi      # 0xbfd0
xorl %eax, %eax
movl %eax, %edx
callq 0x1150
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x3a10
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl (%rcx), %eax
jae 0x17e8
callq 0x1030
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x44c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq -0x20(%rbp), %rax
movl %edx, %ecx
movl %ecx, -0x10(%rbp)
movq (%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4570
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x1bf0
movq (%rax), %rdi
leaq 0x58fc(%rip), %rsi      # 0x70d4
callq 0x5e10
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x176b
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
callq 0x3a10
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x44c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jbe 0x1854
movl $0x8, %edi
callq 0x1070
movq %rax, %rdi
leaq 0x5813(%rip), %rax      # 0x7054
movq %rax, (%rdi)
movq 0xa785(%rip), %rsi      # 0xbfd0
xorl %eax, %eax
movl %eax, %edx
callq 0x1150
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x3a10
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl (%rcx), %eax
jae 0x18d8
callq 0x1030
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x44e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq -0x20(%rbp), %rax
movl %edx, %ecx
movl %ecx, -0x10(%rbp)
movq (%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0x4570
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x1bf0
movq (%rax), %rdi
leaq 0x580c(%rip), %rsi      # 0x70d4
callq 0x5e10
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x185b
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x1c10
movl $0x0, -0x20(%rbp)
movq -0x50(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x70(%rbp)
callq 0x44c0
movq %rax, -0x68(%rbp)
jmp 0x3830
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
cmpq %rcx, %rax
jae 0x3947
movl $0x0, -0x30(%rbp)
movq -0x50(%rbp), %rdi
movl -0x30(%rbp), %eax
movq %rax, -0x80(%rbp)
callq 0x44e0
movq %rax, -0x78(%rbp)
jmp 0x385e
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
cmpq %rcx, %rax
jae 0x3937
movq -0x50(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x3a60
movq %rax, %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x3a80
movq %rax, -0x88(%rbp)
jmp 0x3893
movq -0x88(%rbp), %rax
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5d30
jmp 0x38a8
leaq -0x38(%rbp), %rdi
callq 0x5db0
movq %rax, -0x90(%rbp)
jmp 0x38ba
movq -0x90(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x3920
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x5e30
jmp 0x38ea
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3ac0
jmp 0x38f9
jmp 0x3920
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3967
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5dd0
jmp 0x3967
leaq -0x38(%rbp), %rdi
callq 0x5dd0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3848
jmp 0x3939
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x381a
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x395a
movq -0x60(%rbp), %rdi
callq 0x1fc0
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x1fc0
movq -0x28(%rbp), %rdi
callq 0x1160
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x45f0
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x4610
jmp 0x41ff
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x424e
movq -0x48(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x3a60
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x46a0
jmp 0x4230
jmp 0x4232
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4206
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x42f2
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x42ec
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x42dc
movl $0x8, %edi
callq 0x10e0
movq %rax, -0x50(%rbp)
jmp 0x4286
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5cf0
jmp 0x4295
movq -0x48(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x3a60
movq %rax, %rdi
movslq -0x38(%rbp), %rsi
callq 0x1bf0
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x426b
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x8, %esi
callq 0x10f0
jmp 0x42f2
jmp 0x42de
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4255
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x1160
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x45f0
movq -0x10(%rbp), %rdi
callq 0x44c0
movq %rax, -0x38(%rbp)
jmp 0x434d
movq -0x38(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x4610
jmp 0x435c
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44c0
movq %rax, -0x58(%rbp)
jmp 0x437a
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
cmpq %rcx, %rax
jae 0x4496
movq -0x48(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x3a60
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44e0
movq %rax, -0x68(%rbp)
jmp 0x43ab
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x46a0
jmp 0x43ba
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44e0
movq %rax, -0x78(%rbp)
jmp 0x43d8
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
cmpq %rcx, %rax
jae 0x4486
movq -0x48(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x3a60
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
callq 0x1bf0
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x4510
jmp 0x4423
leaq -0x30(%rbp), %rdi
callq 0x5db0
movq %rax, -0x90(%rbp)
jmp 0x4435
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x5e10
jmp 0x444a
leaq -0x30(%rbp), %rdi
callq 0x5dd0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x43c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x449f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5dd0
jmp 0x449f
jmp 0x4488
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4363
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2040
movq -0x18(%rbp), %rdi
callq 0x1160
nopw %cs:(%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/utils.h
// Function: Utils::read_time_in_seconds()
inline float read_time_in_seconds() {
    struct rusage r_usage;
    getrusage(RUSAGE_SELF, &r_usage);
    float time = (float)r_usage.ru_utime.tv_sec + (float)r_usage.ru_utime.tv_usec / (float)1000000;
    getrusage(RUSAGE_CHILDREN, &r_usage);
    time += (float)r_usage.ru_utime.tv_sec + (float)r_usage.ru_utime.tv_usec / (float)1000000;
    return time;
}

// Assembly:
subq $0x98, %rsp
xorl %edi, %edi
leaq 0x8(%rsp), %rsi
callq 0x61c0
cvtsi2ssq 0x8(%rsp), %xmm0
cvtsi2ssq 0x10(%rsp), %xmm1
movss 0x54aef(%rip), %xmm2    # 0x5d008
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq 0x8(%rsp), %rsi
callq 0x61c0
cvtsi2ssq 0x8(%rsp), %xmm0
cvtsi2ssq 0x10(%rsp), %xmm1
movss 0x54abc(%rip), %xmm2    # 0x5d008
divss %xmm2, %xmm1
addss %xmm1, %xmm0
addss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x4(%rsp), %xmm0
addq $0x98, %rsp
retq
nop
// File: bonetblai[P]mdp-engine/ctp3/../engine/random.h
// Function: Random::set_seed(int)
inline void set_seed(int seed) {
    unsigned short useed[3];
    useed[0] = useed[1] = useed[2] = seed;
    srand48((long int)seed);
    seed48(useed);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movw %ax, 0x12(%rsp)
movw %ax, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movslq 0x14(%rsp), %rdi
callq 0x6500
leaq 0xe(%rsp), %rdi
callq 0x6160
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: probability_bad_weather(CTP::graph_t const&, unsigned int)
inline float probability_bad_weather(const CTP::graph_t &graph, unsigned nsamples) {
    float prob = 0;
    state_t weather(0);
    for( unsigned i = 0; i < nsamples; ++i ) {
        sample_weather(graph, weather);
        //weather.preprocess();
        prob += weather.reachable(graph.num_nodes_ - 1) ? 0 : 1;
    }
    return prob / nsamples;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movl %esi, 0x9c(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x98(%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x113d0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x9c(%rsp), %eax
jae 0x9371
movq 0xa0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x199d0
jmp 0x9307
movq 0xa0(%rsp), %rax
movl (%rax), %esi
decl %esi
leaq 0x28(%rsp), %rdi
callq 0x14210
movb %al, 0x13(%rsp)
jmp 0x9323
movb 0x13(%rsp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cvtsi2ss %eax, %xmm0
addss 0x98(%rsp), %xmm0
movss %xmm0, 0x98(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x92e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x115b0
jmp 0x93a8
movss 0x98(%rsp), %xmm0
movl 0x9c(%rsp), %eax
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x115b0
movss 0xc(%rsp), %xmm0
addq $0xa8, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x6520
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x168, %rsp            # imm = 0x168
movq %rdi, 0x158(%rsp)
movl %esi, 0x154(%rsp)
movq 0x158(%rsp), %rsi
leaq 0x128(%rsp), %rdi
callq 0x19bd0
movl $0x0, 0x124(%rsp)
movl 0x124(%rsp), %eax
cmpl 0x154(%rsp), %eax
jae 0x9565
movq 0x158(%rsp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq %rax, 0x18(%rsp)
jmp 0x9422
movq 0x18(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
callq 0x16650
jmp 0x9436
jmp 0x9438
movq 0x158(%rsp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq 0xb0(%rsp), %rsi
callq *%rax
movb %al, 0x17(%rsp)
jmp 0x9457
movb 0x17(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9466
jmp 0x9533
leaq 0x128(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x19c10
movl %eax, 0x10(%rsp)
jmp 0x9481
movl 0x10(%rsp), %eax
movl %eax, 0xa0(%rsp)
cmpl $-0x1, 0xa0(%rsp)
jne 0x94cd
jmp 0x9533
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x95d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x9556
movq 0x158(%rsp), %rsi
movl 0xa0(%rsp), %ecx
leaq 0x28(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0x19da0
jmp 0x94f0
leaq 0xb0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x17c20
jmp 0x9504
leaq 0x28(%rsp), %rdi
callq 0x19f70
jmp 0x9438
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x19f70
jmp 0x9556
leaq 0xb0(%rsp), %rdi
callq 0x115b0
movl 0x124(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x124(%rsp)
jmp 0x93f6
leaq 0xb0(%rsp), %rdi
callq 0x115b0
jmp 0x95d1
movq 0x158(%rsp), %rax
movss 0x9c(%rax), %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x158(%rsp), %rax
cvtsi2ssl 0x98(%rax), %xmm0
movss %xmm0, 0x20(%rsp)
leaq 0x24(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x19f80
movaps %xmm0, (%rsp)
jmp 0x95a6
movaps (%rsp), %xmm0
movlpd %xmm0, 0x160(%rsp)
leaq 0x128(%rsp), %rdi
callq 0x19fb0
movsd 0x160(%rsp), %xmm0
addq $0x168, %rsp            # imm = 0x168
retq
leaq 0x128(%rsp), %rdi
callq 0x19fb0
movq 0xa8(%rsp), %rdi
callq 0x6520
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/dispatcher.h
// Function: Dispatcher::dispatcher_t<state_t>::solve(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Algorithm::algorithm_t<state_t> const&, state_t const&, Dispatcher::dispatcher_t<state_t>::solve_result_t&) const
void dispatcher_t<T>::solve(const std::string &name, const Algorithm::algorithm_t<T> &algorithm, const T &s, solve_result_t &result) const {
    std::cout << "dispatcher: solve: " << name << std::endl;
    const Problem::problem_t<T> &problem = algorithm.problem();

    result.name_ = name;
    result.algorithm_ = &algorithm;
    result.state_ = s;
    result.seed_ = algorithm.seed();
    Random::set_seed(result.seed_);

    float start_time = Utils::read_time_in_seconds();
    Problem::hash_t<T> *hash = new Problem::hash_t<T>(problem);
    algorithm.solve(s, *hash);
    float end_time = Utils::read_time_in_seconds();

    // expansions from problem
    result.problem_expansions_ = problem.expansions();

    // extract stats from hash
    result.hash_ = hash;

    // time stats
    result.time_raw_ = end_time - start_time;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x77bbc(%rip), %rdi     # 0x82fd0
leaq 0x54d29(%rip), %rsi     # 0x60144
callq 0x6330
movq %rax, %rdi
movq 0x48(%rsp), %rsi
callq 0x62f0
movq %rax, %rdi
movq 0x77b81(%rip), %rsi     # 0x82fb8
callq 0x6370
movq 0x40(%rsp), %rdi
callq 0x58f30
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rsi
movq 0x30(%rsp), %rdi
addq $0x70, %rdi
callq 0x6060
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x90(%rax)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x17c20
movq 0x40(%rsp), %rdi
callq 0x58f40
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x98(%rax)
movq 0x30(%rsp), %rax
movl 0x98(%rax), %edi
callq 0x8f50
callq 0x84f0
movss %xmm0, 0x24(%rsp)
movl $0x58, %edi
callq 0x6340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x34540
jmp 0xb4d4
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
callq 0x84f0
movss %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x58f50
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x9c(%rax)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0xa0(%rax)
movss 0x8(%rsp), %xmm0
subss 0x24(%rsp), %xmm0
movq 0x30(%rsp), %rax
movss %xmm0, 0xb0(%rax)
addq $0x58, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
callq 0x6310
movq 0x10(%rsp), %rdi
callq 0x6520
nopw %cs:(%rax,%rax)
nop
// File: bonetblai[P]mdp-engine/ctp3/../engine/dispatcher.h
// Function: Dispatcher::dispatcher_t<state_t>::evaluate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Online::Policy::policy_t<state_t> const&, state_t const&, Dispatcher::dispatcher_t<state_t>::evaluate_result_t&, unsigned int, unsigned int, bool) const
void dispatcher_t<T>::evaluate(const std::string &name, const Online::Policy::policy_t<T> &policy, const T &s, evaluate_result_t &result, unsigned num_trials, unsigned max_evaluation_depth, bool verbose) const {
    std::cout << "dispatcher: evaluate: " << name << std::endl;
    const Problem::problem_t<T> &problem = policy.problem();
    policy.reset_stats();

    result.name_ = name;
    result.policy_ = &policy;
    result.seed_ = policy.seed();
    Random::set_seed(result.seed_);

    float start_time = Utils::read_time_in_seconds();
    std::pair<float, float> p = Online::Evaluation::evaluation_with_stdev(policy, problem.init(), num_trials, max_evaluation_depth, verbose);
    result.eval_value_ = p.first;
    result.eval_stdev_ = p.second;
    float end_time = Utils::read_time_in_seconds();

    // expansions from problem
    result.problem_expansions_ = problem.expansions();

    // time stats
    result.time_raw_ = end_time - start_time;
}

// Assembly:
subq $0x58, %rsp
movb 0x68(%rsp), %al
movl 0x60(%rsp), %r10d
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
andb $0x1, %al
movb %al, 0x2b(%rsp)
movq 0x76b18(%rip), %rdi     # 0x82fd0
leaq 0x53d95(%rip), %rsi     # 0x60254
callq 0x6330
movq %rax, %rdi
movq 0x48(%rsp), %rsi
callq 0x62f0
movq %rax, %rdi
movq 0x76add(%rip), %rsi     # 0x82fb8
callq 0x6370
movq 0x40(%rsp), %rdi
callq 0x1ac80
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movq 0x48(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x6060
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x40(%rsp), %rdi
callq 0x5afb0
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x30(%rsp), %rax
movl 0x28(%rax), %edi
callq 0x8f50
callq 0x84f0
movss %xmm0, 0x1c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x2c(%rsp), %edx
movl 0x60(%rsp), %ecx
movzbl 0x2b(%rsp), %r8d
andl $0x1, %r8d
callq 0x5afc0
movlpd %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
movq 0x30(%rsp), %rax
movss %xmm0, 0x30(%rax)
movss 0x18(%rsp), %xmm0
movq 0x30(%rsp), %rax
movss %xmm0, 0x34(%rax)
callq 0x84f0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x58f50
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x2c(%rax)
movss 0x10(%rsp), %xmm0
subss 0x1c(%rsp), %xmm0
movq 0x30(%rsp), %rax
movss %xmm0, 0x38(%rax)
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x75205(%rip), %rax     # 0x81e88
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x1ca20
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1ca50
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x1ca90
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x1ca50
leaq 0x78(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1ca70
testb $0x1, %al
jne 0xccde
jmp 0xcd10
leaq 0x78(%rsp), %rdi
callq 0x1cac0
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xcd02
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xcd04
leaq 0x78(%rsp), %rdi
callq 0x1caf0
jmp 0xcca7
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x1cb20
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1cb50
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x1cb90
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1cb50
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1cb70
testb $0x1, %al
jne 0xcd69
jmp 0xcd9b
leaq 0x58(%rsp), %rdi
callq 0x1cbc0
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xcd8d
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xcd8f
leaq 0x58(%rsp), %rdi
callq 0x1cbf0
jmp 0xcd32
movq 0x18(%rsp), %rdi
addq $0x68, %rdi
callq 0x1cc20
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1cc50
movq 0x18(%rsp), %rdi
addq $0x68, %rdi
callq 0x1cc90
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1cc50
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1cc70
testb $0x1, %al
jne 0xcdf4
jmp 0xce24
leaq 0x38(%rsp), %rdi
callq 0x1ccc0
movq 0x20(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xce16
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xce18
leaq 0x38(%rsp), %rdi
callq 0x1ccf0
jmp 0xcdbd
movq 0x18(%rsp), %rdi
addq $0x68, %rdi
callq 0x1cd20
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x1cd30
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x1cd40
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/./graph.h
// Function: CTP::graph_t::add_edge(CTP::graph_t::edge_t const&)
int add_edge(const edge_t &edge) {
        assert((int)edge_list_.size() == num_edges_);
        edge_list_.push_back(edge);
        at_[edge.from_].push_back(num_edges_);
        at_[edge.to_].push_back(num_edges_);
        edges_[edge.from_ * num_nodes_ + edge.to_] = num_edges_;
        edges_[edge.to_ * num_nodes_ + edge.from_] = num_edges_;
        return num_edges_++;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x10, %rdi
callq 0xed20
movq (%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0xd9bb
jmp 0xd9da
leaq 0x4f9d3(%rip), %rdi     # 0x5d395
leaq 0x4f9f1(%rip), %rsi     # 0x5d3ba
movl $0x43, %edx
leaq 0x4f9ef(%rip), %rcx     # 0x5d3c4
callq 0x6220
movq (%rsp), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0xed40
movq (%rsp), %rdi
addq $0x28, %rdi
movq 0x8(%rsp), %rax
movslq (%rax), %rsi
callq 0xdc90
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x4, %rsi
callq 0xedb0
movq (%rsp), %rdi
addq $0x28, %rdi
movq 0x8(%rsp), %rax
movslq 0x4(%rax), %rsi
callq 0xdc90
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x4, %rsi
callq 0xedb0
movq (%rsp), %rcx
movl 0x4(%rcx), %esi
movq 0x40(%rcx), %rax
movq 0x8(%rsp), %rdx
movl (%rdx), %edx
imull (%rcx), %edx
movq 0x8(%rsp), %rdi
addl 0x4(%rdi), %edx
movslq %edx, %rdx
movl %esi, (%rax,%rdx,4)
movl 0x4(%rcx), %esi
movq 0x40(%rcx), %rax
movq 0x8(%rsp), %rdx
movl 0x4(%rdx), %edx
imull (%rcx), %edx
movq 0x8(%rsp), %rdi
addl (%rdi), %edx
movslq %edx, %rdx
movl %esi, (%rax,%rdx,4)
movl 0x4(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x4(%rcx)
addq $0x18, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/./graph.h
// Function: CTP::graph_t::degree() const
int degree() const {
        int d = 0;
        for( int node = 0; node < num_nodes_; ++node ) {
            int dn = degree(node);
            d = dn > d ? dn : d;
        }
        return d;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl (%rcx), %eax
jge 0xdb43
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0xfd20
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jle 0xdb26
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0xdb2e
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xdaf3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movl %ecx, 0x18(%rax)
movslq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jge 0x111e6
movl $0x38, %edi
callq 0x6340
movq %rax, %rdi
movq %rdi, (%rsp)
callq 0x111f0
movq 0x8(%rsp), %rax
movq (%rsp), %rdx
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x111a0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movl %ecx, 0x10(%rax)
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jge 0x11516
movl $0x38, %edi
callq 0x6340
movq %rax, %rdi
movq %rdi, (%rsp)
callq 0x11f20
movq 0x8(%rsp), %rax
movq (%rsp), %rdx
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x114d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)