LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::OFB_encrypt()
void Cipher::OFB_encrypt(){   
    Sequence ivSq(16), ivOriginal(16);
    time_t rawtime;
    struct tm * timeinfo;
    unsigned char iv[16];
    time(&rawtime);
    timeinfo = localtime(&rawtime);
    strftime ((char *)iv, 16, "%r", timeinfo);
    ivSq.setSequence(iv);
    ivOriginal.updateSequence(ivSq);        //Keep track of IV to write it in Ciphertext
    
    //Encrypt
    for(Sequence sq: inputBlock->getSequenceVector()){
        encrypt(&ivSq, aesKeyExp);
        sq = sq ^ ivSq;
    }

    //Authenticate
    inputBlock->getSequenceVector().
        insert(inputBlock->getSequenceVector().begin(), ivOriginal);    //Append IV to Ciphertext
    Sequence tag = CBC_MAC(*inputBlock, true, false);       //Get MAC Tag, we are encrypting without padding
    
    //Write ciphertext after encryption and authentication
    writeCipherText(&tag);
    /* Sequence cleanup as it can leave traces in memory */
    ivSq.~Sequence();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x58(%rsp), %r14
pushq $0x10
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x2ea0
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x2ea0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x21d0
movq %r12, %rdi
callq 0x2150
leaq 0x234d(%rip), %rdx      # 0x77e9
leaq 0x40(%rsp), %r12
pushq $0x10
popq %rsi
movq %r12, %rdi
movq %rax, %rcx
callq 0x2180
movq %r14, %rdi
movq %r12, %rsi
callq 0x2ebc
movq (%r14), %rsi
movl 0x8(%r14), %edx
movq %r15, %rdi
callq 0x2f3c
movq 0x10(%rbx), %rdi
callq 0x318e
movq (%rax), %r12
movq 0x8(%rax), %r13
movq %rsp, %r15
cmpq %r13, %r12
je 0x5509
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4984
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fe8
addq $0x10, %r12
jmp 0x54dc
movq 0x10(%rbx), %rdi
callq 0x318e
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x318e
movq (%rax), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x5856
movq 0x10(%rbx), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x597a
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x4d22
movq %rsp, %r14
movq %rax, (%r14)
movl %edx, 0x8(%r14)
leaq 0x10(%rsp), %rdi
callq 0x316c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5052
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x316c
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x597a
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4d22
leaq 0x58(%rsp), %r14
movq %rax, (%r14)
movl %edx, 0x8(%r14)
leaq 0x18(%rsp), %rdi
callq 0x316c
movq 0x10(%rbx), %rdi
callq 0x318e
movq %rax, %rdi
xorl %esi, %esi
callq 0x58c0
movups (%rax), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %r14, %rdx
callq 0x4ebe
testb %al, %al
je 0x568a
leaq 0x48(%rsp), %r14
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x2ea0
movq 0x10(%rbx), %rdi
callq 0x318e
movq (%rax), %r12
movq 0x8(%rax), %r13
pushq $-0x1
popq %rbp
movq %rsp, %r15
cmpq %r13, %r12
je 0x5673
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
testl %ebp, %ebp
jle 0x565b
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4984
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fe8
jmp 0x566b
movq (%rsp), %rsi
movl 0x8(%rsp), %edx
movq %r14, %rdi
callq 0x2f3c
addq $0x10, %r12
incl %ebp
jmp 0x562e
movq %rbx, %rdi
callq 0x4f8a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x2100
leaq 0x211a(%rip), %rcx      # 0x77b3
movq %rcx, (%rax)
movq 0x5925(%rip), %rsi      # 0xafc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x23a0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x316c
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
callq 0x32b4
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x32a4
movq %rbx, %rdi
callq 0x2120
movq %rsp, %rdi
movq %rax, %rsi
callq 0x3612
movq %rbx, %rdi
callq 0x2060
movq 0x4d82(%rip), %rdi      # 0x7ff0
leaq 0x1e16(%rip), %rsi      # 0x508b
callq 0x20e0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x2110
movq %rsp, %rdi
callq 0x21d8
callq 0x2180
jmp 0x323e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21d8
callq 0x2180
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x2850
// File: /workspace/github_cpp_makefile_star2_O2/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::iter()
void Bjorklund::iter(){
    //\Bjorklund algorithm
    //\do E[k,n]. k is number of one's in sequence, and n is the length of sequence.
    int divisor = lengthOfSeq - pulseAmt; //initial amount of zero's
    if(divisor < 0) throw out_of_range{"Divisor has to be greator than 0"};
    
    remainder.push_back(pulseAmt);
    //iteration
    int index = 0; //we start algorithm from first index.
    
    while(true){
        count.push_back(std::floor(divisor / remainder[index]));
        remainder.push_back(divisor % remainder[index]);
        divisor = remainder.at(index);
        index += 1; //move to next step.
        if(remainder[index] <= 1){
            break;
        }
    }
    count.push_back(divisor);
    buildSeq(index); //place one's and zero's
    reverse(sequence.begin(), sequence.end());
    
    //position correction. some of result of algorithm is one step rotated.
    int zeroCount =0;
    if(sequence.at(0) != 1){
        do{
            zeroCount ++;
        }while(sequence.at(zeroCount) == 0);
        std::rotate(sequence.begin(), sequence.begin() + zeroCount, sequence.end());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x58(%rdi), %ebp
subl 0x5c(%rdi), %ebp
js 0x33c4
movq %rdi, %rbx
leaq 0x5c(%rdi), %rsi
callq 0x362c
leaq 0x18(%rbx), %r15
movq (%rbx), %rax
movl (%rax), %ecx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3878
movq (%rbx), %rcx
movl %ebp, %eax
cltd
idivl (%rcx,%r14,4)
movl %edx, 0xc(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3878
movq %rbx, %rdi
movq %r14, %rsi
callq 0x364a
movl (%rax), %ebp
movl %ebp, 0x14(%rsp)
movq (%rbx), %rax
movl 0x4(%rax,%r14,4), %ecx
incq %r14
cmpl $0x1, %ecx
jg 0x32f0
leaq 0x14(%rsp), %rsi
movq %r15, %rdi
callq 0x362c
movq %rbx, %rdi
movl %r14d, %esi
callq 0x348e
leaq 0x30(%rbx), %r14
movq 0x30(%rbx), %rdi
movq 0x40(%rbx), %rdx
movl 0x48(%rbx), %ecx
xorl %esi, %esi
callq 0x398e
movq %r14, %rdi
xorl %esi, %esi
callq 0x366c
testq %rdx, (%rax)
jne 0x33b5
xorl %r15d, %r15d
incq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x366c
testq %rdx, (%rax)
je 0x337e
movl %r15d, %eax
shrl $0x6, %eax
movq 0x30(%rbx), %rdi
movq 0x40(%rbx), %r8
leaq (%rdi,%rax,8), %rdx
andl $0x3f, %r15d
movl 0x48(%rbx), %r9d
xorl %esi, %esi
movl %r15d, %ecx
callq 0x3acd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2080
movq %rax, %rbx
leaq 0x1cc9(%rip), %rsi      # 0x509f
movq %rax, %rdi
callq 0x2030
movq 0x4beb(%rip), %rsi      # 0x7fd0
movq 0x4bdc(%rip), %rdx      # 0x7fc8
movq %rbx, %rdi
callq 0x21b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movl %esi, 0x58(%rdi)
movl %edx, 0x5c(%rdi)
callq 0x32b4
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x347e
movq %rbx, %rdi
callq 0x2120
movq %rsp, %rdi
movq %rax, %rsi
callq 0x3612
movq %rbx, %rdi
callq 0x2060
movq 0x4ba8(%rip), %rdi      # 0x7ff0
leaq 0x1c3c(%rip), %rsi      # 0x508b
callq 0x20e0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x2110
movq %rsp, %rdi
callq 0x21d8
callq 0x2180
jmp 0x3418
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21d8
callq 0x2180
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x2850
// File: /workspace/github_cpp_makefile_star2_O2/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 0x34e4
cmpl $-0x1, %r14d
je 0x34e0
leal -0x1(%r14), %ebp
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
cmpl (%rax,%r14,4), %r15d
jge 0x34c7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x348e
incl %r15d
jmp 0x34ae
movq (%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
leaq -0x2(%r14), %r14
jne 0x349b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x34e6
movb $0x1, %al
addq $0x30, %rbx
movzbl %al, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x368e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
xorl %r15d, %r15d
movq 0x4aa7(%rip), %r12      # 0x7fc0
movq 0x40(%rbx), %rax
movl 0x48(%rbx), %ecx
subq 0x30(%rbx), %rax
leaq (%rcx,%rax,8), %rax
cmpq %rax, %r15
je 0x354e
movq %r14, %rdi
movq %r15, %rsi
callq 0x366c
xorl %esi, %esi
testq %rdx, (%rax)
setne %sil
movq %r12, %rdi
callq 0x2190
incq %r15
jmp 0x3519
movq 0x4a6b(%rip), %r14      # 0x7fc0
pushq $0xa
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x2110
leaq 0x1b57(%rip), %rsi      # 0x50c0
movq %r14, %rdi
callq 0x20e0
movq 0x40(%rbx), %rcx
movl 0x48(%rbx), %edx
subq 0x30(%rbx), %rcx
leaq (%rdx,%rcx,8), %rsi
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, (%rdi)
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
andl $0x0, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movq %rsi, %r14
leaq 0x30(%rsi), %r15
xorl %r12d, %r12d
movslq 0x58(%r14), %rax
cmpq %rax, %r12
jge 0x35ef
movq %r15, %rdi
movq %r12, %rsi
callq 0x27d0
xorl %esi, %esi
testq %rdx, (%rax)
setne %sil
movq %rbx, %rdi
callq 0x368e
incq %r12
jmp 0x35c5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x27ee
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq -0x30(%rbp), %rsi
andl $0x0, (%rsi)
andl $0x0, -0x2c(%rbp)
movq 0x2df4(%rip), %rdi      # 0x3fe0
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x12c3
pushq $0x1
popq %r13
movq 0x2dd2(%rip), %rbx      # 0x3fe0
leaq -0x2c(%rbp), %r14
leaq 0xdf4(%rip), %r15       # 0x200d
movl %r13d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1283
movl -0x30(%rbp), %esi
cmpl %esi, -0x2c(%rbp)
jne 0x1242
incl %r12d
jmp 0x121c
movq 0x2d87(%rip), %rdi      # 0x3fd0
callq 0x1080
movq %rax, %rdi
leaq 0xdac(%rip), %rsi       # 0x2004
callq 0x1060
movq %rax, %rdi
movl %r12d, %esi
callq 0x1080
movq %rax, %rdi
movq %r15, %rsi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x1219
movl -0x30(%rbp), %esi
movq 0x2d43(%rip), %rdi      # 0x3fd0
callq 0x1080
leaq 0xd6b(%rip), %rsi       # 0x2004
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
movl %r12d, %esi
callq 0x1080
leaq 0xd5a(%rip), %rsi       # 0x200d
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JayWalker512[P]JayParser/main.cpp
// Function: main
int main (int argc, const char *argv[])
{
	Log *log = Log::init();
	
	if (argc != 2)
		log->add(new Error(FATAL + FILEERR + 1, "Invalid argument count. Expecting program file name."));
	else
	{
		std::ifstream inputFile(argv[1], std::ios::binary);
		
		if (!inputFile.is_open())
			log->add(new Error(FATAL + FILEERR + 2, "Can't open the file."));
		else
		{
			// Everything's looking good, starting the VM
			VM vm(&inputFile);
			vm.parse();
		}
	}
	
	Log::init()->displayLastError();
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x40298, %rsp          # imm = 0x40298
movq %rsi, %r14
movl %edi, %r15d
callq 0x2568
movq %rax, %rbx
cmpl $0x2, %r15d
jne 0x2427
movq 0x8(%r14), %rsi
leaq -0x260(%rbp), %rdi
pushq $0x4
popq %rdx
callq 0x2200
leaq -0x1e8(%rbp), %rdi
callq 0x2030
testb %al, %al
je 0x247c
leaq -0x402b0(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x2c24
leaq -0x402b0(%rbp), %rdi
callq 0x2cb6
leaq -0x402b0(%rbp), %rdi
callq 0x2cb0
jmp 0x24cf
pushq $0x28
popq %rdi
callq 0x2130
movq %rax, %r14
leaq 0x1bcb(%rip), %rsi      # 0x4004
leaq -0x58(%rbp), %rdi
leaq -0x402b0(%rbp), %rdx
callq 0x25d0
movl $0x80ffff01, (%r14)     # imm = 0x80FFFF01
movq %r14, %rdi
addq $0x8, %rdi
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
callq 0x2170
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25b2
leaq -0x58(%rbp), %rdi
callq 0x2090
jmp 0x24db
pushq $0x28
popq %rdi
callq 0x2130
movq %rax, %r14
leaq 0x1bab(%rip), %rsi      # 0x4039
leaq -0x38(%rbp), %rdi
leaq -0x402b0(%rbp), %rdx
callq 0x25d0
movl $0x80ffff02, (%r14)     # imm = 0x80FFFF02
movq %r14, %rdi
addq $0x8, %rdi
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
callq 0x2170
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25b2
leaq -0x38(%rbp), %rdi
callq 0x2090
leaq -0x260(%rbp), %rdi
callq 0x2040
callq 0x2568
movq %rax, %rdi
callq 0x260c
xorl %eax, %eax
addq $0x40298, %rsp          # imm = 0x40298
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2526
movq %rax, %rbx
leaq -0x402b0(%rbp), %rdi
callq 0x2cb0
jmp 0x2531
jmp 0x2510
movq %rax, %rbx
jmp 0x2531
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2090
testb %r15b, %r15b
je 0x2531
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x2140
leaq -0x260(%rbp), %rdi
callq 0x2040
jmp 0x2560
movq %rax, %rbx
jmp 0x2555
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2090
testb %r15b, %r15b
je 0x2560
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x40020(%rdi)
andq $0x0, 0x4002c(%rdi)
movq %rsi, 0x40040(%rdi)
callq 0x2568
movq %rax, 0x40048(%rbx)
xorl %eax, %eax
cmpq $0xffff, %rax           # imm = 0xFFFF
je 0x2c63
andl $0x0, (%rbx,%rax,4)
incq %rax
jmp 0x2c52
leaq 0x3fffc(%rbx), %rax
movq %rax, 0x40000(%rbx)
leaq 0x3fff8(%rbx), %rax
movq %rax, 0x40008(%rbx)
leaq 0x3fff4(%rbx), %rax
movq %rax, 0x40010(%rbx)
leaq 0x3fff0(%rbx), %rax
movq %rax, 0x40018(%rbx)
leaq 0x3ffc0(%rbx), %rax
movq %rax, 0x40038(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2cea
movq 0x40048(%rbx), %rdi
callq 0x29ce
testl %eax, %eax
je 0x2cdb
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2df4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0xddffddff, %esi       # imm = 0xDDFFDDFF
callq 0x315e
movq 0x40040(%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
jne 0x2d69
movq %rbx, %rdi
callq 0x33cc
movl 0x4002c(%rbx), %eax
movl %eax, %ecx
shll $0x10, %ecx
addl 0x40030(%rbx), %ecx
cmpl $0xccffccff, %ecx       # imm = 0xCCFFCCFF
je 0x2dbf
xorl %r14d, %r14d
cmpl %eax, %r14d
jae 0x2d04
movq 0x40040(%rbx), %rdi
callq 0x2150
movl 0x40030(%rbx), %ecx
addl %r14d, %ecx
movl %eax, (%rbx,%rcx,4)
incl %r14d
movl 0x4002c(%rbx), %eax
jmp 0x2d41
movq 0x40048(%rbx), %r14
pushq $0x28
popq %rdi
callq 0x2130
movq %rax, %rbx
leaq 0x13f5(%rip), %rsi      # 0x4177
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x25d0
movl $0x80ffee05, (%rbx)     # imm = 0x80FFEE05
movq %rbx, %rdi
addq $0x8, %rdi
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
callq 0x2170
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25b2
leaq -0x40(%rbp), %rdi
callq 0x2090
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2de0
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x2090
testb %r15b, %r15b
je 0x2deb
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40040(%rdi), %rdi
leaq -0x22(%rbp), %r15
movq %r15, %rsi
callq 0x2180
movq 0x40040(%r14), %rdi
leaq -0x21(%rbp), %r12
movq %r12, %rsi
callq 0x2180
movzbl (%r15), %eax
shll $0x8, %eax
movzbl (%r12), %ecx
orl %eax, %ecx
movl %ecx, (%rbx)
incl 0x40024(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
andl $0x0, (%r15)
movq 0x40040(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2160
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3038
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3038
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3038
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3038
cmpl %r14d, -0x20(%rbp)
je 0x3226
movq 0x40040(%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
je 0x31aa
movq 0x40048(%rbx), %r14
pushq $0x28
popq %rdi
callq 0x2130
movq %rax, %rbx
leaq 0xf6f(%rip), %rsi       # 0x4158
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x25d0
movl $0x80ffee04, (%rbx)     # imm = 0x80FFEE04
movq %rbx, %rdi
addq $0x8, %rdi
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
callq 0x2170
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25b2
leaq -0x40(%rbp), %rdi
callq 0x2090
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3247
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x2090
testb %r15b, %r15b
je 0x3252
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
callq 0x3070
movq 0x40040(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2160
movq 0x40040(%r14), %rdi
callq 0x2150
cmpb $0x8, %al
jne 0x32ad
movq 0x40040(%r14), %rdi
callq 0x2150
movzbl %al, %eax
cmpl 0x40028(%r14), %eax
je 0x336e
movq 0x40040(%r14), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rdi,%rax)
je 0x3288
movq 0x40048(%r14), %r15
pushq $0x28
popq %rdi
callq 0x2130
movq %rax, %rbx
leaq 0xec8(%rip), %rsi       # 0x41a3
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x25d0
movl $0x80ffff03, (%rbx)     # imm = 0x80FFFF03
movq %rbx, %rdi
addq $0x8, %rdi
movb $0x1, %r12b
leaq -0x68(%rbp), %rsi
callq 0x2170
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x25b2
leaq -0x68(%rbp), %rdi
callq 0x2090
movq 0x40048(%r14), %r14
pushq $0x28
popq %rdi
callq 0x2130
movq %rax, %rbx
leaq 0xe97(%rip), %rsi       # 0x41c8
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x25d0
movl $0x80ffee02, (%rbx)     # imm = 0x80FFEE02
movq %rbx, %rdi
addq $0x8, %rdi
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
callq 0x2170
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25b2
leaq -0x48(%rbp), %rdi
callq 0x2090
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x337d
movq %rax, %r14
jmp 0x33a6
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2090
testb %r15b, %r15b
jne 0x33a6
jmp 0x33b1
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x2090
testb %r12b, %r12b
je 0x33b1
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/JayWalker512[P]JayParser/./VM.h
// Function: VM::execJMF()
inline void execJMF() {
		if (*m_lgf != 0)
			execJMP();
		else
			skipNextInstruction();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x40038(%rdi), %rax
cmpl $0x0, (%rax)
je 0x3412
popq %rbp
jmp 0x325a
popq %rbp
jmp 0x30de
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
pushq $0x8
popq %rdi
callq 0x10d0
movq %rax, %rbx
leaq -0x24(%rbp), %rsi
movl $0x8, (%rsi)
movq %rax, %rdi
callq 0x1480
movq %rbx, %rdi
callq 0x16b4
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x10d0
movq %rax, %r12
leaq 0x4972(%rip), %rax      # 0x5d78
addq $0x10, %rax
movq %rax, (%r12)
movq %r14, %rdi
callq 0x10d0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x145c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1466
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rbx
jmp 0x1449
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x10e0
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2098
movl (%rax), %r14d
movq (%rbx), %rdi
callq 0x24a8
cmpq %r14, %rax
jb 0x15d2
xorl %r13d, %r13d
leaq -0x2c(%rbp), %r14
leaq 0x1b5d(%rip), %r15      # 0x30d4
movq (%rbx), %rdi
callq 0x2098
movl (%rax), %eax
cmpq %rax, %r13
jae 0x15c3
callq 0x1030
movslq %eax, %r12
movq (%rbx), %rdi
callq 0x248c
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movl %edx, -0x2c(%rbp)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x24f6
movq (%rax), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
callq 0x2ac4
incq %r13
jmp 0x1577
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x1070
leaq 0x1a46(%rip), %rcx      # 0x3027
movq %rcx, (%rax)
movq 0x49e5(%rip), %rsi      # 0x5fd0
movq %rax, %rdi
xorl %edx, %edx
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2098
movl (%rax), %r14d
movq (%rbx), %rdi
callq 0x248c
cmpq %r14, %rax
jb 0x1690
xorl %r12d, %r12d
leaq -0x24(%rbp), %r14
leaq 0x1aa6(%rip), %r15      # 0x30d4
movl %r12d, -0x24(%rbp)
movq (%rbx), %rdi
callq 0x2098
cmpl (%rax), %r12d
jae 0x1683
callq 0x1030
movslq %eax, %r12
movq (%rbx), %rdi
callq 0x24a8
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r12
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x24f6
movq (%rax), %rax
movslq %r12d, %rcx
movq (%rax,%rcx,8), %rdi
movq %r15, %rsi
callq 0x2ac4
movl -0x24(%rbp), %r12d
incl %r12d
jmp 0x162e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x1070
leaq 0x19b5(%rip), %rcx      # 0x3054
movq %rcx, (%rax)
movq 0x4927(%rip), %rsi      # 0x5fd0
movq %rax, %rdi
xorl %edx, %edx
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2098
movl (%rax), %ebx
movq (%r15), %rdi
callq 0x248c
movq %rax, %r12
movq %r15, -0x38(%rbp)
movq (%r15), %rdi
callq 0x24a8
imulq %r12, %rax
cmpq %rbx, %rax
jb 0x1823
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, (%rax)
movq %rax, %r14
andq $0x0, 0x10(%rax)
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 0x248c
movslq %ebx, %rcx
cmpq %rcx, %rax
jbe 0x176d
xorl %ebx, %ebx
movl %ebx, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x24a8
movslq %ebx, %rcx
cmpq %rcx, %rax
jbe 0x1766
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2ad4
movq %r14, %rdi
movq %r15, %rsi
callq 0x18a8
movl -0x2c(%rbp), %ebx
incl %ebx
jmp 0x172f
movl -0x30(%rbp), %ebx
incl %ebx
jmp 0x1716
movq -0x50(%rbp), %rbx
movq -0x48(%rbp), %r15
xorl %edi, %edi
callq 0x10b0
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
leaq -0x58(%rbp), %rax
movq %rdx, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x18e3
xorl %r12d, %r12d
leaq 0x1927(%rip), %rbx      # 0x30d4
xorl %r13d, %r13d
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x2098
movl (%rax), %eax
cmpq %rax, %r13
jae 0x180b
movq -0x38(%rbp), %rax
movq (%rax), %r15
movq -0x50(%rbp), %rdi
addq %r12, %rdi
callq 0x2b1c
movq %r15, %rdi
movq %rax, %rsi
callq 0x24f6
movq %rax, %r15
movq -0x50(%rbp), %rdi
addq %r12, %rdi
callq 0x2b12
movslq (%rax), %rax
movq (%r15), %rcx
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x2ac4
incq %r13
addq $0x8, %r12
jmp 0x17b0
leaq -0x50(%rbp), %rdi
callq 0x1aec
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x1070
leaq 0x184c(%rip), %rcx      # 0x307e
movq %rcx, (%rax)
movq 0x4794(%rip), %rsi      # 0x5fd0
movq %rax, %rdi
xorl %edx, %edx
callq 0x1140
jmp 0x184e
jmp 0x184e
jmp 0x184e
jmp 0x184e
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1aec
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movl $0x0, -0x2c(%rbp)
leaq -0x50(%rbp), %r12
movq %rsi, -0x48(%rbp)
movq %r15, %rdi
callq 0x248c
movl -0x2c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x202d
xorl %r13d, %r13d
imulq $0x18, %rcx, %rbx
movq %r15, %rdi
callq 0x24a8
movl %r13d, %esi
cmpq %rsi, %rax
jbe 0x2025
movq (%r15), %rdi
addq %rbx, %rdi
callq 0x20a2
movq (%rax), %rsi
movq %r12, %rdi
callq 0x2a7e
movq %r12, %rdi
callq 0x2aa2
movl (%rax), %eax
cmpl (%r14), %eax
jne 0x2015
movq %r12, %r15
movq %rbx, %r12
movq %r14, %rbx
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 0x2ad4
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2154
movq %rbx, %r14
movq %r12, %rbx
movq %r15, %r12
movq -0x48(%rbp), %r15
movq %r12, %rdi
callq 0x2aac
incl %r13d
jmp 0x1fa0
incl -0x2c(%rbp)
jmp 0x1f85
movq -0x38(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2054
jmp 0x2044
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2aac
jmp 0x2057
jmp 0x2054
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x1aec
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, -0x38(%rbp)
movl (%rsi), %esi
movq %rdi, -0x30(%rbp)
callq 0x2530
xorl %ebx, %ebx
xorl %r12d, %r12d
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpq %rax, %r12
jae 0x22e4
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq %rbx, %rdi
movl (%r15), %esi
callq 0x2572
incq %r12
addq $0x18, %rbx
jmp 0x22be
xorl %ecx, %ecx
movl %eax, %eax
cmpq %rax, %rcx
jae 0x2338
movq %rcx, -0x40(%rbp)
imulq $0x18, %rcx, %r13
xorl %ebx, %ebx
movl (%r15), %eax
cmpq %rax, %rbx
jae 0x2329
pushq $0x8
popq %rdi
callq 0x10d0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x2a5c
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax,%r13), %rax
movq %r12, (%rax,%rbx,8)
incq %rbx
jmp 0x22f7
movq -0x40(%rbp), %rcx
incq %rcx
movq -0x38(%rbp), %rax
movl (%rax), %eax
jmp 0x22e6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x235b
jmp 0x235b
movq %rax, %r14
pushq $0x8
popq %rsi
movq %r12, %rdi
callq 0x10e0
jmp 0x235e
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x1a0a
movq %r14, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rdi, -0x30(%rbp)
movq %rax, %rsi
callq 0x2530
movq (%r14), %rcx
xorl %edi, %edi
leaq -0x48(%rbp), %r15
movl %edi, -0x38(%rbp)
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %rdi, %rax
jbe 0x2456
movq %rdi, -0x40(%rbp)
imulq $0x18, %rdi, %r13
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq %r13, %rdi
movq 0x8(%rcx), %rsi
subq (%rcx), %rsi
sarq $0x3, %rsi
callq 0x2572
xorl %ebx, %ebx
movl %ebx, -0x34(%rbp)
movq (%r14), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x3, %rax
cmpq %rbx, %rax
jbe 0x244a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax,%r13), %rax
movq (%rax,%rbx,8), %r12
movq %r15, %rdi
movq %r14, %rsi
leaq -0x38(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x24bc
movq %r15, %rdi
callq 0x2aa2
movq %r12, %rdi
movq %rax, %rsi
callq 0x2ac4
movq %r15, %rdi
callq 0x2aac
incq %rbx
jmp 0x23f2
movq -0x40(%rbp), %rdi
incq %rdi
jmp 0x23b3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2469
jmp 0x2469
movq %rax, %r14
jmp 0x247a
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2aac
movq -0x30(%rbp), %rdi
callq 0x1a0a
movq %r14, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0xa0, %rsp
leaq 0x10(%rsp), %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x5180
cvtsi2ssq (%rbx), %xmm0
movss %xmm0, 0x8(%rsp)
cvtsi2ssq 0x8(%rbx), %xmm0
movss %xmm0, 0xc(%rsp)
pushq $-0x1
popq %rdi
movq %rbx, %rsi
callq 0x5180
cvtsi2ssq (%rbx), %xmm1
addss 0x8(%rsp), %xmm1
cvtsi2ssq 0x8(%rbx), %xmm0
addss 0xc(%rsp), %xmm0
mulss 0x19cba(%rip), %xmm0    # 0x20004
addss %xmm1, %xmm0
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
leaq 0xa(%rsp), %rbx
movw %di, 0x4(%rbx)
movw %di, 0x2(%rbx)
movw %di, (%rbx)
movslq %edi, %rdi
callq 0x53f0
movq %rbx, %rdi
callq 0x5100
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: problem_t::problem_t(CTP::graph_t&, float, bool, unsigned int)
void print(std::ostream &os) const {
        os << "K={";
        for( int i = 0; i < words_for_edges_; ++i )
            os << print_bits_t<unsigned>(known_[i], i << 5);
        os << "},B={";
        for( int i = 0; i < words_for_edges_; ++i )
            os << print_bits_t<unsigned>(blocked_[i], i << 5);
        os << "}";
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x3f800000, 0x8(%rdi)  # imm = 0x3F800000
movss %xmm0, 0xc(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x2d5af(%rip), %rax     # 0x33eb0
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
orl $-0x1, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rdi)
movups %xmm0, 0x34(%rdi)
movups %xmm0, 0x44(%rdi)
movups %xmm0, 0x54(%rdi)
andq $0x0, 0x64(%rdi)
movb $0x1, 0x7c(%rdi)
andq $0x0, 0x80(%rdi)
orl $-0x1, 0x88(%rdi)
movups %xmm0, 0x6c(%rdi)
andl $0x0, 0x90(%rdi)
movl (%rsi), %eax
decl %eax
movl %eax, 0x94(%rdi)
andq $0x0, 0x98(%rdi)
leaq 0x20(%rdi), %rbx
movb %dl, 0xa0(%rdi)
leaq 0xa8(%rdi), %r14
andl $0x0, 0xa8(%rdi)
movups %xmm0, 0xb0(%rdi)
andq $0x0, 0xc0(%rdi)
movl (%rsi), %esi
movq %r14, %rdi
movl %ecx, %edx
callq 0x8dca
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x8e46
movq %rbx, %rdi
callq 0x8e90
movq %r15, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, 0x8(%r14)
movl 0x2e826(%rip), %eax     # 0x352c0
movl %eax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%r14)
leaq 0x2d4ab(%rip), %rax     # 0x33f58
movq %rax, (%r14)
xorl %r13d, %r13d
leaq 0x30(%rsp), %r15
leaq 0xa0(%rsp), %r12
cmpl %ebp, %r13d
je 0x6b2b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0xa4d8
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rax)
testb %al, %al
jne 0x6b1e
movq %r14, %rdi
movq %r15, %rsi
callq 0xb222
cmpl $-0x1, %eax
je 0x6b1e
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0xb318
movq %r15, %rdi
movq %r12, %rsi
callq 0xa8c8
movq %r12, %rdi
callq 0x8e90
jmp 0x6ad9
movq %r15, %rdi
callq 0x8e90
incl %r13d
jmp 0x6ac0
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 0x6b69
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x8e90
jmp 0x6b6c
jmp 0x6b69
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8e90
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x2d81a(%rip), %rdi     # 0x34fd8
leaq 0x1b938(%rip), %rsi     # 0x230fd
callq 0x5290
movq %rax, %rdi
movq %r12, %rsi
callq 0x5250
movq %rax, %rdi
callq 0x5130
movq 0x8(%r15), %r13
leaq 0x70(%rbx), %rdi
movq %r12, %rsi
callq 0x5160
movq %r15, 0x90(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa8c8
movl 0x18(%r15), %edi
movl %edi, 0x98(%rbx)
callq 0x6763
callq 0x62f2
movss %xmm0, 0xc(%rsp)
pushq $0x58
popq %rdi
callq 0x52a0
movq %rax, %r12
addq $0x38, %rax
movq %rax, 0x8(%r12)
movq $0x1, 0x10(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
movl $0x3f800000, 0x28(%r12) # imm = 0x3F800000
andq $0x0, 0x40(%r12)
movups %xmm0, 0x30(%r12)
leaq 0x2ce9d(%rip), %rax     # 0x346f8
movq %rax, (%r12)
movq %r13, 0x48(%r12)
andl $0x0, 0x50(%r12)
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq *0x28(%rax)
callq 0x62f2
movl 0x10(%r13), %eax
movl %eax, 0x9c(%rbx)
movq %r12, 0xa0(%rbx)
subss 0xc(%rsp), %xmm0
movss %xmm0, 0xb0(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r13
movb 0x48(%rsp), %r14b
movq 0x2d11d(%rip), %rdi     # 0x34fd8
leaq 0x1b34b(%rip), %rsi     # 0x2320d
callq 0x5290
movq %rax, %rdi
movq %r13, %rsi
callq 0x5250
movq %rax, %rdi
callq 0x5130
movq (%r15), %rax
movq 0x8(%r15), %r12
movq %r15, %rdi
callq *0x28(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5160
movq %r15, 0x20(%rbx)
movl 0x10(%r15), %edi
movl %edi, 0x28(%rbx)
callq 0x6763
callq 0x62f2
movss %xmm0, 0x4(%rsp)
movq (%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movzbl %r14b, %r8d
movq %r15, %rdi
movq %rax, %rsi
movl %ebp, %edx
movl 0x40(%rsp), %ecx
callq 0x1f593
movlps %xmm0, 0x30(%rbx)
callq 0x62f2
movl 0x10(%r12), %eax
movl %eax, 0x2c(%rbx)
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop