LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/block.cpp
// Function: Block::dump(std::ostream&, bool)
void Block::dump(ostream &strm, bool with_comments) {
    if ( w_vector ){
        vector<inst*>::iterator it = instructions.vinst->begin();
        for (; it != instructions.vinst->end(); ++ it) {
            strm << ((inst*)(*it))->to_string(with_comments) << endl;
        }
    } else {
        list<inst*>::iterator it = instructions.linst->begin();
        for (; it != instructions.linst->end(); ++ it) {
            strm << ((inst*)(*it))->to_string(with_comments) << endl;
        }
    }
}

// Assembly:
subq $0xc8, %rsp
movb %dl, %al
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
andb $0x1, %al
movb %al, 0xb7(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x38(%rsp)
testb $0x1, 0x4(%rax)
je 0x3303d
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x34ba0
movq %rax, 0xa8(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x34c10
movq %rax, 0xa0(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x34bd0
testb $0x1, %al
jne 0x32f93
jmp 0x33038
movq 0xb8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x34c40
movq (%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
movzbl 0xb7(%rsp), %edx
andl $0x1, %edx
leaq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x6340
movq %rax, 0x30(%rsp)
jmp 0x32fe6
movq 0x30(%rsp), %rdi
movq 0x3afa6(%rip), %rsi     # 0x6df98
callq 0x63d0
jmp 0x32ff9
leaq 0x80(%rsp), %rdi
callq 0x6778
leaq 0xa8(%rsp), %rdi
callq 0x34c50
jmp 0x32f5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6778
jmp 0x33118
jmp 0x33110
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x34c70
movq %rax, 0x68(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x34cc0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x34ca0
testb $0x1, %al
jne 0x3307b
jmp 0x3310e
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x34cf0
movq (%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
movzbl 0xb7(%rsp), %edx
andl $0x1, %edx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq *%rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6340
movq %rax, 0x18(%rsp)
jmp 0x330c8
movq 0x18(%rsp), %rdi
movq 0x3aec4(%rip), %rsi     # 0x6df98
callq 0x63d0
jmp 0x330db
leaq 0x40(%rsp), %rdi
callq 0x6778
leaq 0x68(%rsp), %rdi
callq 0x34d10
jmp 0x33050
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x6778
jmp 0x33118
jmp 0x33110
addq $0xc8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/block.cpp
// Function: Block::max_label()
unsigned int Block::max_label(){
    
    unsigned int maxl = 0;
    
    if ( w_vector ){
        
        unsigned int nsize = instructions.vinst->size();
        for (unsigned int i=0; i<nsize; i++){
            inst* current_inst = (*(instructions.vinst))[i];
            maxl = max(maxl, current_inst->label);
        }
        
    } else {
        
        list<inst*>::iterator it = instructions.linst->begin();
        for( ; it != instructions.linst->end(); ++it){
            inst* current_inst = *it;
            maxl = max(maxl, current_inst->label);
        }
    }
    
    return maxl;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x3c(%rsp)
testb $0x1, 0x4(%rax)
je 0x331b9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x34d30
movl %eax, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x38(%rsp), %eax
jae 0x331b7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x34(%rsp), %eax
movl %eax, %esi
callq 0x34d50
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
leaq 0x3c(%rsp), %rdi
callq 0x34d70
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x3316b
jmp 0x3322d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x34c70
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x34cc0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x34ca0
testb $0x1, %al
jne 0x331f4
jmp 0x3322b
leaq 0x20(%rsp), %rdi
callq 0x34cf0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
leaq 0x3c(%rsp), %rdi
callq 0x34d70
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x34d10
jmp 0x331cc
jmp 0x3322d
movl 0x3c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: opd::opd(int, char)
opd::opd(int s, char type){

    data.pint = s;
    this->type = type;
    switch (type) {
        case O_LABEL: case O_INT:
            data.pint = s;
            break;
        case O_SL:
            data.spim.lab = s;
            break;
        case O_SI:
            data.spim.imm = s;
            break;
        default:
            throw string("") + "Error de implementaci�n, tipo " + itoa_(type) + " de instrucci�n desconocido";
    }
}

// Assembly:
subq $0xb8, %rsp
movb %dl, %al
movq %rdi, 0xb0(%rsp)
movl %esi, 0xac(%rsp)
movb %al, 0xab(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0xac(%rsp), %ecx
movl %ecx, (%rax)
movb 0xab(%rsp), %cl
movb %cl, 0x10(%rax)
movsbl 0xab(%rsp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, 0x28(%rsp)
subl $0xe, %eax
ja 0x380b5
movq 0x28(%rsp), %rax
leaq 0x1c422(%rip), %rcx     # 0x54494
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rax
movl 0xac(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x381f0
movq 0x20(%rsp), %rax
movl 0xac(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x381f0
movq 0x20(%rsp), %rax
movl 0xac(%rsp), %ecx
movl %ecx, 0x4(%rax)
jmp 0x381f0
movb $0x1, 0x33(%rsp)
movl $0x20, %edi
callq 0x61b0
movq %rax, 0x10(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x66c0
movq 0x18(%rsp), %rdx
leaq 0x1c26e(%rip), %rsi     # 0x54352
leaq 0x48(%rsp), %rdi
callq 0x7500
jmp 0x380f0
leaq 0x1c50c(%rip), %rdx     # 0x54603
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x20990
jmp 0x38108
movsbl 0xab(%rsp), %edi
callq 0x293a0
movq %rax, 0x8(%rsp)
jmp 0x3811c
movq 0x8(%rsp), %rdx
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x20990
jmp 0x38135
movq 0x10(%rsp), %rdi
leaq 0x1c4e1(%rip), %rdx     # 0x54622
leaq 0x88(%rsp), %rsi
callq 0x20990
jmp 0x38150
movq 0x10(%rsp), %rdi
movb $0x0, 0x33(%rsp)
leaq 0x35b4f(%rip), %rsi     # 0x6dcb0
movq 0x35e40(%rip), %rdx     # 0x6dfa8
callq 0x6670
jmp 0x38202
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x381d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x381c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x381bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x6778
leaq 0x68(%rsp), %rdi
callq 0x6778
leaq 0x48(%rsp), %rdi
callq 0x6778
leaq 0x47(%rsp), %rdi
callq 0x6400
testb $0x1, 0x33(%rsp)
jne 0x381e4
jmp 0x381ee
movq 0x10(%rsp), %rdi
callq 0x62b0
jmp 0x381f8
addq $0xb8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: opd::opd(int, int, char)
opd::opd(int s1, int s2, char type){

    this->type = type;
    switch (type) {
        case O_SLI:
            data.spim.lab = s1;
            data.spim.imm = s2;
            break;
        case O_SLR:
            data.spim.lab = s1;
            data.spim.reg = s2;
            break;
        case O_SIR:
            data.spim.imm = s1;
            data.spim.reg = s2;
            break;
        default:
            throw string("") + "Error de implementaci�n, tipo " + itoa_(type) + " de instrucci�n desconocido";
    }
}

// Assembly:
subq $0xb8, %rsp
movb %cl, %al
movq %rdi, 0xb0(%rsp)
movl %esi, 0xac(%rsp)
movl %edx, 0xa8(%rsp)
movb %al, 0xa7(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0xa7(%rsp), %cl
movb %cl, 0x10(%rax)
movsbl 0xa7(%rsp), %eax
movl %eax, 0x24(%rsp)
subl $0x18, %eax
je 0x38276
jmp 0x38260
movl 0x24(%rsp), %eax
subl $0x28, %eax
je 0x38293
jmp 0x3826b
movl 0x24(%rsp), %eax
subl $0x30, %eax
je 0x382b0
jmp 0x382ce
movq 0x18(%rsp), %rax
movl 0xac(%rsp), %ecx
movl %ecx, (%rax)
movl 0xa8(%rsp), %ecx
movl %ecx, 0x4(%rax)
jmp 0x38407
movq 0x18(%rsp), %rax
movl 0xac(%rsp), %ecx
movl %ecx, (%rax)
movl 0xa8(%rsp), %ecx
movl %ecx, 0x8(%rax)
jmp 0x38407
movq 0x18(%rsp), %rax
movl 0xac(%rsp), %ecx
movl %ecx, 0x4(%rax)
movl 0xa8(%rsp), %ecx
movl %ecx, 0x8(%rax)
jmp 0x38407
movb $0x1, 0x2b(%rsp)
movl $0x20, %edi
callq 0x61b0
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x66c0
movq 0x10(%rsp), %rdx
leaq 0x1c055(%rip), %rsi     # 0x54352
leaq 0x40(%rsp), %rdi
callq 0x7500
jmp 0x38309
leaq 0x1c2f3(%rip), %rdx     # 0x54603
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x20990
jmp 0x38321
movsbl 0xa7(%rsp), %edi
callq 0x293a0
movq %rax, (%rsp)
jmp 0x38334
movq (%rsp), %rdx
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x20990
jmp 0x3834c
movq 0x8(%rsp), %rdi
leaq 0x1c2ca(%rip), %rdx     # 0x54622
leaq 0x80(%rsp), %rsi
callq 0x20990
jmp 0x38367
movq 0x8(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
leaq 0x35938(%rip), %rsi     # 0x6dcb0
movq 0x35c29(%rip), %rdx     # 0x6dfa8
callq 0x6670
jmp 0x38419
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x383e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x383de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x383d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6778
leaq 0x60(%rsp), %rdi
callq 0x6778
leaq 0x40(%rsp), %rdi
callq 0x6778
leaq 0x3f(%rsp), %rdi
callq 0x6400
testb $0x1, 0x2b(%rsp)
jne 0x383fb
jmp 0x38405
movq 0x8(%rsp), %rdi
callq 0x62b0
jmp 0x3840f
addq $0xb8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x66b0
nopl (%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: opd::opd(int, int, int)
opd::opd(int lab, int imm, int reg){

    this->type = O_SLIR;
    data.spim.lab = lab;
    data.spim.imm = imm;
    data.spim.reg = reg;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movb $0x38, 0x10(%rax)
movl -0xc(%rsp), %ecx
movl %ecx, (%rax)
movl -0x10(%rsp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
retq
nop
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: inst::get_goal_label()
unsigned int inst::get_goal_label(){
    assert (op == GOTO);
    if (0 != arg2) {
        return arg2->data.pint;
    } else {
        return -1;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x16, 0xc(%rax)
jne 0x38d9a
jmp 0x38db9
leaq 0x1b8af(%rip), %rdi     # 0x54650
leaq 0x1b8b3(%rip), %rsi     # 0x5465b
movl $0x79, %edx
leaq 0x1b8b4(%rip), %rcx     # 0x54668
callq 0x6250
movq (%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x38dd5
movq (%rsp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x38ddd
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: inst::is_jump()
bool inst::is_jump(){
    switch ( op ){
        case GOTO:
        case IF:
        case IFEQ:
        case IFNEQ:
        case IFL:
        case IFLEQ:
        case IFG:
        case IFGEQ:
        case RETURN:
        case CALL:
        case EPILOGUE:
            return true;
        default:
            return false;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x14(%rsp)
subl $0x1, %eax
je 0x38e24
jmp 0x38e08
movl -0x14(%rsp), %eax
addl $-0xf, %eax
subl $0x2, %eax
jb 0x38e24
jmp 0x38e16
movl -0x14(%rsp), %eax
addl $-0x16, %eax
subl $0x7, %eax
ja 0x38e2b
jmp 0x38e24
movb $0x1, -0x1(%rsp)
jmp 0x38e30
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: inst::mandatory_jump()
bool inst::mandatory_jump(){
    assert(is_jump());
    switch ( op ){
        case GOTO:
//        case CALL:
        case RETURN:
        case EPILOGUE:
            return true;
        default:
            return false;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0x38e5f
jmp 0x38e61
jmp 0x38e80
leaq 0x1b824(%rip), %rdi     # 0x5468c
leaq 0x1b7ec(%rip), %rsi     # 0x5465b
movl $0x95, %edx
leaq 0x1b81b(%rip), %rcx     # 0x54696
callq 0x6250
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rsp)
addl $-0xf, %eax
subl $0x2, %eax
jb 0x38ea1
jmp 0x38e96
movl 0xc(%rsp), %eax
subl $0x16, %eax
jne 0x38ea8
jmp 0x38ea1
movb $0x1, 0x27(%rsp)
jmp 0x38ead
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: quad::quad(inst::OP, opd*, opd*, opd*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
quad::quad(OP op, opd *arg0, opd *arg1, opd *arg2, string comment){
    this->op = op;
    this->arg0 = arg0;
    this->arg1 = arg1;
    this->arg2 = arg2;
    if (comment.compare("")) {
        comment = "# " + comment + "\n";
    }
    this->comment = comment;
}

// Assembly:
subq $0x98, %rsp
movq %r9, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq %r9, 0x68(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3cbb0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
leaq 0x34dab(%rip), %rcx     # 0x6dcc0
addq $0x10, %rcx
movq %rcx, (%rax)
movl 0x8c(%rsp), %ecx
movl %ecx, 0xc(%rax)
movq 0x80(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x78(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x70(%rsp), %rcx
movq %rcx, 0x20(%rax)
leaq 0x1b407(%rip), %rsi     # 0x54352
callq 0x6110
cmpl $0x0, %eax
je 0x38fd4
movq 0x10(%rsp), %rdx
leaq 0x1b759(%rip), %rsi     # 0x546ba
leaq 0x28(%rsp), %rdi
callq 0x351c0
jmp 0x38f6d
leaq 0x1b3dd(%rip), %rdx     # 0x54351
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x20990
jmp 0x38f85
movq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x64c0
leaq 0x48(%rsp), %rdi
callq 0x6778
leaq 0x28(%rsp), %rdi
callq 0x6778
jmp 0x38fd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x38ff1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6778
jmp 0x38ff1
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
callq 0x6060
jmp 0x38fe9
addq $0x98, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x3cbe0
movq 0x20(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/string_table.cpp
// Function: string_table::string_table()
string_table::string_table() {
    offset = 0;
    push_back("Se trató de utilizar una propiedad no activa de la unión en (");
    push_back(", ");
    push_back(")");
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
callq 0x32120
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x66c0
movq 0x20(%rsp), %rdx
leaq 0x15bbc(%rip), %rsi     # 0x547df
leaq 0x90(%rsp), %rdi
callq 0x7500
jmp 0x3ec32
movq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x3edd0
jmp 0x3ec46
leaq 0x90(%rsp), %rdi
callq 0x6778
leaq 0x8f(%rsp), %rdi
callq 0x6400
leaq 0x57(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x66c0
movq 0x8(%rsp), %rdx
leaq 0x13db7(%rip), %rsi     # 0x52a32
leaq 0x58(%rsp), %rdi
callq 0x7500
jmp 0x3ec87
movq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3edd0
jmp 0x3ec98
leaq 0x58(%rsp), %rdi
callq 0x6778
leaq 0x57(%rsp), %rdi
callq 0x6400
leaq 0x2f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x66c0
movq (%rsp), %rdx
leaq 0x1381f(%rip), %rsi     # 0x524e4
leaq 0x30(%rsp), %rdi
callq 0x7500
jmp 0x3ecd1
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3edd0
jmp 0x3ece2
leaq 0x30(%rsp), %rdi
callq 0x6778
leaq 0x2f(%rsp), %rdi
callq 0x6400
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x3ed2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x6778
leaq 0x8f(%rsp), %rdi
callq 0x6400
jmp 0x3edb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x3ed6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x6778
leaq 0x57(%rsp), %rdi
callq 0x6400
jmp 0x3edb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x3eda6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6778
leaq 0x2f(%rsp), %rdi
callq 0x6400
movq 0x10(%rsp), %rdi
callq 0x30330
movq 0x80(%rsp), %rdi
callq 0x66b0
nopw (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/string_table.cpp
// Function: string_table::push_back(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int string_table::push_back(string s) {
    table.push_back(s);
    int t = offset;
    offset += s.length() + 1;//El null para asciiz
    return t;
}

// Assembly:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x3f120
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
callq 0x65c0
movq %rax, %rdx
movq 0x8(%rsp), %rax
addq $0x1, %rdx
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/string_table.cpp
// Function: string_table::to_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string string_table::to_string(string s) {
    string ss = "";
    for (unsigned int i = 0; i < s.length(); ++ i) {
        if ('\\' == s[i]) ss += '\\';
        ss += s[i];
    }
    return ss;
}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
leaq 0x56(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x66c0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
leaq 0x154cd(%rip), %rsi     # 0x54352
callq 0x7500
jmp 0x3ee8c
leaq 0x56(%rsp), %rdi
callq 0x6400
movl $0x0, 0x40(%rsp)
movq 0x20(%rsp), %rdi
movl 0x40(%rsp), %eax
movq %rax, 0x18(%rsp)
callq 0x65c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x3ef6e
movq 0x20(%rsp), %rdi
movl 0x40(%rsp), %eax
movl %eax, %esi
callq 0x6760
movq %rax, 0x10(%rsp)
jmp 0x3eed9
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
movl $0x5c, %eax
cmpl %ecx, %eax
jne 0x3ef31
movq 0x30(%rsp), %rdi
movl $0x5c, %esi
callq 0x6220
jmp 0x3eefb
jmp 0x3ef31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x56(%rsp), %rdi
callq 0x6400
jmp 0x3ef8e
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x6778
jmp 0x3ef8e
movq 0x20(%rsp), %rdi
movl 0x40(%rsp), %eax
movl %eax, %esi
callq 0x6760
movq %rax, 0x8(%rsp)
jmp 0x3ef48
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movsbl (%rax), %esi
callq 0x6220
jmp 0x3ef5c
jmp 0x3ef5e
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x3ee9e
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x3ef84
movq 0x30(%rsp), %rdi
callq 0x6778
movq 0x28(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x66b0
nopl (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/main.cpp
// Function: main_ast_create(main_args)
AST* main_ast_create(main_args args){

    p = new AST();
    yyin = args.in;
    do {
        yyparse();
    } while (!feof(yyin));

    if (args.to_single_archive){
        main_redirect_stdout("bla.output");
    }
    return p;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x28, %edi
callq 0x6390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x1f100
jmp 0x4baa9
movq (%rsp), %rax
movq %rax, 0x229ec(%rip)     # 0x6e4a0
movq 0x20(%rsp), %rax
movq %rax, 0x22aa8(%rip)     # 0x6e568
callq 0x3f490
movq 0x22a9c(%rip), %rdi     # 0x6e568
callq 0x65e0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4bac0
testb $0x1, 0x18(%rsp)
je 0x4bb10
leaq 0xc207(%rip), %rdi      # 0x57cf2
callq 0x4bc20
jmp 0x4bb10
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x28, %esi
callq 0x63a0
jmp 0x4bb1c
movq 0x22989(%rip), %rax     # 0x6e4a0
addq $0x28, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/main.cpp
// Function: main_ast_check(AST*)
string_table* main_ast_check(AST *ast){

    string_table* strings = new string_table();
    symbol_table* st = new symbol_table(strings);
    
    ast->fill_and_check(st);
    
    delete st;

    return strings;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x20, %edi
callq 0x6390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x3ebd0
jmp 0x4bb55
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x48, %edi
callq 0x6390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rsi
callq 0x29f70
jmp 0x4bb80
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x4bbc3
movq 0x8(%rsp), %rdi
callq 0x203d0
movq 0x8(%rsp), %rdi
movl $0x48, %esi
callq 0x63a0
movq 0x38(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x20, %esi
callq 0x63a0
jmp 0x4bc09
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x48, %esi
callq 0x63a0
movq 0x30(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/main.cpp
// Function: main_redirect_stdout(char const*)
void main_redirect_stdout(const char *f)
{
    static FILE *fd = 0, *stdout_back = 0;
    static streambuf *rdbuf_back = 0;
    static ofstream filestr;
    if (0 == stdout_back) {
        stdout_back = stdout;
        rdbuf_back = cout.rdbuf();
    }
    if (0 != fd && stdout != fd) {
        fclose(fd);
        filestr.close();
    }
    if (0 == f) {
        stdout = stdout_back;
        cout.rdbuf(rdbuf_back);
    } else {
        fd = stdout = fopen(f, "w");
        filestr.open(f);
        cout.rdbuf(filestr.rdbuf());
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpb $0x0, 0x22bb8(%rip)     # 0x6e7e8
jne 0x4bc77
leaq 0x22baf(%rip), %rdi     # 0x6e7e8
callq 0x66e0
cmpl $0x0, %eax
je 0x4bc77
leaq 0x2299e(%rip), %rdi     # 0x6e5e8
callq 0x6660
jmp 0x4bc51
movq 0x22378(%rip), %rdi     # 0x6dfd0
leaq 0x22989(%rip), %rsi     # 0x6e5e8
leaq 0x2275a(%rip), %rdx     # 0x6e3c0
callq 0x6330
leaq 0x22b76(%rip), %rdi     # 0x6e7e8
callq 0x6240
xorl %eax, %eax
cmpq 0x22958(%rip), %rax     # 0x6e5d8
jne 0x4bcd5
movq 0x222ff(%rip), %rax     # 0x6df88
movq (%rax), %rax
movq %rax, 0x22945(%rip)     # 0x6e5d8
movq 0x22326(%rip), %rax     # 0x6dfc0
movq (%rax), %rax
movq 0x2231c(%rip), %rdi     # 0x6dfc0
addq -0x18(%rax), %rdi
callq 0x6190
movq %rax, 0x2292c(%rip)     # 0x6e5e0
jmp 0x4bcd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x22b1d(%rip), %rdi     # 0x6e7e8
callq 0x6230
jmp 0x4bdb8
xorl %eax, %eax
cmpq 0x228f2(%rip), %rax     # 0x6e5d0
je 0x4bd0b
movq 0x222a1(%rip), %rax     # 0x6df88
movq (%rax), %rax
cmpq 0x228df(%rip), %rax     # 0x6e5d0
je 0x4bd0b
movq 0x228d6(%rip), %rdi     # 0x6e5d0
callq 0x6380
leaq 0x228e2(%rip), %rdi     # 0x6e5e8
callq 0x6580
xorl %eax, %eax
cmpq 0x20(%rsp), %rax
jne 0x4bd48
movq 0x228bd(%rip), %rcx     # 0x6e5d8
movq 0x22266(%rip), %rax     # 0x6df88
movq %rcx, (%rax)
movq 0x22294(%rip), %rax     # 0x6dfc0
movq (%rax), %rax
movq 0x2228a(%rip), %rdi     # 0x6dfc0
addq -0x18(%rax), %rdi
movq 0x2289f(%rip), %rsi     # 0x6e5e0
callq 0x6710
jmp 0x4bdb3
movq 0x20(%rsp), %rdi
leaq 0xc0e7(%rip), %rsi      # 0x57e3b
callq 0x6490
movq 0x22228(%rip), %rcx     # 0x6df88
movq %rax, (%rcx)
movq %rax, 0x22866(%rip)     # 0x6e5d0
movq 0x20(%rsp), %rsi
leaq 0x22872(%rip), %rdi     # 0x6e5e8
movl $0x10, %edx
callq 0x6080
movq 0x22239(%rip), %rax     # 0x6dfc0
movq (%rax), %rcx
movq 0x2222f(%rip), %rax     # 0x6dfc0
addq -0x18(%rcx), %rax
movq %rax, 0x8(%rsp)
leaq 0x22847(%rip), %rdi     # 0x6e5e8
callq 0x66f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6710
addq $0x28, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/main.cpp
// Function: main_tac_create(main_args, AST*)
Tac* main_tac_create(main_args args, AST *ast){

    Tac* tac = ast->to_tac();
    if (args.to_separate_archives) {
        main_redirect_stdout("bla.tac");
    }
    tac->dump(cout, args.tac_with_comments);

    if (!args.to_separate_archives) {
        cout << "-------------------------------------------------------" << endl << endl;
    }

    return tac;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
testb $0x1, 0x19(%rsp)
je 0x4be06
leaq 0xbf7e(%rip), %rdi      # 0x57d7f
callq 0x4bc20
movq 0x8(%rsp), %rdi
movb 0x1b(%rsp), %al
movq 0x221aa(%rip), %rsi     # 0x6dfc0
andb $0x1, %al
movzbl %al, %edx
callq 0x4e100
testb $0x1, 0x19(%rsp)
jne 0x4be58
movq 0x22192(%rip), %rdi     # 0x6dfc0
leaq 0xbe14(%rip), %rsi      # 0x57c49
callq 0x6370
movq %rax, %rdi
movq 0x22154(%rip), %rsi     # 0x6df98
callq 0x63d0
movq %rax, %rdi
movq 0x22145(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/main.cpp
// Function: main_tac_dump(main_args, Tac*)
void main_tac_dump(main_args args, Tac* tac)
{
    main_redirect_stdout();
    cout << "Escribiendo bloques básico en bla.blocks"
         << " y grafo de flujo en bla.png\n\n";
    dump_in_file("bla");

    if (!args.to_separate_archives && !args.to_single_archive) {
        cout << "-------------------------------------------------------" << endl << endl;
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x40(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x4bc20
movq 0x2210d(%rip), %rdi     # 0x6dfc0
leaq 0xbecd(%rip), %rsi      # 0x57d87
callq 0x6370
movq %rax, %rdi
leaq 0xbee8(%rip), %rsi      # 0x57db1
callq 0x6370
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x66c0
movq (%rsp), %rdx
leaq 0x846c(%rip), %rsi      # 0x54353
leaq 0x20(%rsp), %rdi
callq 0x7500
jmp 0x4bef3
leaq 0x20(%rsp), %rdi
callq 0x341f0
jmp 0x4beff
leaq 0x20(%rsp), %rdi
callq 0x6778
leaq 0x1f(%rsp), %rdi
callq 0x6400
testb $0x1, 0x49(%rsp)
jne 0x4bf88
testb $0x1, 0x48(%rsp)
jne 0x4bf88
movq 0x22098(%rip), %rdi     # 0x6dfc0
leaq 0xbd1a(%rip), %rsi      # 0x57c49
callq 0x6370
movq %rax, %rdi
movq 0x2205a(%rip), %rsi     # 0x6df98
callq 0x63d0
movq %rax, %rdi
movq 0x2204b(%rip), %rsi     # 0x6df98
callq 0x63d0
jmp 0x4bf88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x4bf7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6778
leaq 0x1f(%rsp), %rdi
callq 0x6400
jmp 0x4bf8d
addq $0x58, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x66b0
nopw (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/Tac.cpp
// Function: Tac::backpatch(std::__cxx11::list<int, std::allocator<int>>&, int)
void Tac::backpatch(list<int>& l, int instr){
    list<int>::iterator it;
    for (it = l.begin(); it != l.end(); ++it){
        quad* in = (quad*)(*(block->instructions.vinst))[*it];
        in->arg2 = new opd(instr, O_LABEL);
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4e450
movq 0x58(%rsp), %rdi
callq 0x22ea0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
callq 0x208a0
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x230d0
testb $0x1, %al
jne 0x4e026
jmp 0x4e0b7
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x23140
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0x34d50
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x18, %edi
callq 0x6390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl 0x54(%rsp), %esi
movl $0x6, %edx
callq 0x38010
jmp 0x4e07b
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
leaq 0x48(%rsp), %rdi
callq 0x23160
jmp 0x4dfff
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x18, %esi
callq 0x63a0
jmp 0x4e0bc
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/codegen.cpp
// Function: register_descriptor::release_cost()
int register_descriptor::release_cost(){
    
    int cost = 0;
    set<symbol*>::iterator it = variables_available.begin();
    
    for ( ; it != variables_available.end(); ++it){
        symbol* s = *it;
        if ( s->availability.size() == 1 )
            cost++;
    }
    
    return cost;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, 0x2c(%rsp)
addq $0x28, %rdi
callq 0x4ed50
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
callq 0x4ed10
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4ecb0
testb $0x1, %al
jne 0x4e961
jmp 0x4e9a0
leaq 0x20(%rsp), %rdi
callq 0x4ed80
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0x4eda0
cmpq $0x1, %rax
jne 0x4e992
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x4e994
leaq 0x20(%rsp), %rdi
callq 0x4edb0
jmp 0x4e939
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: SethKasmann[P]clever-girl/main.cpp
// Function: main
int main(int argc, char* argv[])
{
    mg_init();
    Zobrist::init();
    bb_init();
    uci();
    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x26b90
callq 0x3fe10
callq 0x205d0
callq 0x3e520
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: SethKasmann[P]clever-girl/src/MagicMoves.cpp
// Function: initmagicmoves_occ(int const*, int, unsigned long long)
U64 initmagicmoves_occ(const int* squares, const int numSquares, const U64 linocc)
{
	int i;
	U64 ret=0;
	for(i=0;i<numSquares;i++)
		if(linocc&(((U64)(1))<<i)) ret|=(((U64)(1))<<squares[i]);
	return ret;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq $0x0, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x1fe56
movq -0x18(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1fe47
movq -0x8(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
orq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
jmp 0x1fe49
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x1fdff
movq -0x28(%rsp), %rax
retq
nopl (%rax)
// File: SethKasmann[P]clever-girl/src/MagicMoves.cpp
// Function: initmagicmoves_Rmoves(int, unsigned long long)
U64 initmagicmoves_Rmoves(const int square, const U64 occ)
{
	U64 ret=0;
	U64 bit;
	U64 rowbits=(((U64)0xFF)<<(8*(square/8)));
	
	bit=(((U64)(1))<<square);
	do
	{
		bit<<=8;
		ret|=bit;
	}while(bit && !(bit&occ));
	bit=(((U64)(1))<<square);
	do
	{
		bit>>=8;
		ret|=bit;
	}while(bit && !(bit&occ));
	bit=(((U64)(1))<<square);
	do
	{
		bit<<=1;
		if(bit&rowbits) ret|=bit;
		else break;
	}while(!(bit&occ));
	bit=(((U64)(1))<<square);
	do
	{
		bit>>=1;
		if(bit&rowbits) ret|=bit;
		else break;
	}while(!(bit&occ));
	return ret;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movl -0x4(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
shll $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0xff, %eax
shlq %cl, %rax
movq %rax, -0x28(%rsp)
movl -0x4(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
shlq $0x8, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
orq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rsp)
movb %al, -0x29(%rsp)
je 0x1fee7
movq -0x20(%rsp), %rax
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
testb $0x1, %al
jne 0x1fea5
movl -0x4(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
orq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rsp)
movb %al, -0x2a(%rsp)
je 0x1ff44
movq -0x20(%rsp), %rax
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x2a(%rsp)
movb -0x2a(%rsp), %al
testb $0x1, %al
jne 0x1ff02
movl -0x4(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
shlq %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
andq -0x28(%rsp), %rax
cmpq $0x0, %rax
je 0x1ff8d
movq -0x20(%rsp), %rax
orq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0x1ff8f
jmp 0x1ffa8
jmp 0x1ff91
movq -0x20(%rsp), %rax
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ff5f
movl -0x4(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
shrq %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
andq -0x28(%rsp), %rax
cmpq $0x0, %rax
je 0x1ffe9
movq -0x20(%rsp), %rax
orq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0x1ffeb
jmp 0x20004
jmp 0x1ffed
movq -0x20(%rsp), %rax
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ffbb
movq -0x18(%rsp), %rax
retq
nopw (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/bitboard.cpp
// Function: print_bb(unsigned long long)
void print_bb(U64 bb)
{
    const U64 MSB = 0x8000000000000000ULL;
    std::string ret;
    for (int i = 0; i < 64; ++i)
    {
        if (i % 8 == 0)
        {
            if (i != 0)
            {
                ret.append("\n");
            }
            for (int j = 0; j < 8; ++j)
            {
                ret.append("+-");
            }
            ret.append("+\n|");
        }
        U64 bit = pow(2, i);
        if (bb << i & MSB)
        {
            ret.append("1|");
        }
        else
        {
            ret.append("0|");
        }
    }
    ret.append("\n");
    for (int j = 0; j < 8; ++j)
    {
        ret.append("+-");
    }
    ret.append("+\n");
    std::cout << ret;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x48(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5390
movl $0x0, 0x24(%rsp)
cmpl $0x40, 0x24(%rsp)
jge 0x213de
movl 0x24(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x21345
cmpl $0x0, 0x24(%rsp)
je 0x212ff
leaq 0x1f91a(%rip), %rsi     # 0x40bee
leaq 0x28(%rsp), %rdi
callq 0x5500
jmp 0x212e0
jmp 0x212ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5538
jmp 0x21457
movl $0x0, 0x10(%rsp)
cmpl $0x8, 0x10(%rsp)
jge 0x21330
leaq 0x1f8cb(%rip), %rsi     # 0x40be0
leaq 0x28(%rsp), %rdi
callq 0x5500
jmp 0x21321
jmp 0x21323
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x21307
leaq 0x1f8ac(%rip), %rsi     # 0x40be3
leaq 0x28(%rsp), %rdi
callq 0x5500
jmp 0x21343
jmp 0x21345
cvtsi2sdl 0x24(%rsp), %xmm1
movsd 0x1f87d(%rip), %xmm0    # 0x40bd0
callq 0x54a0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x1f869(%rip), %xmm1    # 0x40bd8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movl 0x24(%rsp), %ecx
shlq %cl, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rax
cmpq $0x0, %rax
je 0x213b7
leaq 0x1f83e(%rip), %rsi     # 0x40be7
leaq 0x28(%rsp), %rdi
callq 0x5500
jmp 0x213b5
jmp 0x213cc
leaq 0x1f82c(%rip), %rsi     # 0x40bea
leaq 0x28(%rsp), %rdi
callq 0x5500
jmp 0x213ca
jmp 0x213cc
jmp 0x213ce
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x212aa
leaq 0x1f809(%rip), %rsi     # 0x40bee
leaq 0x28(%rsp), %rdi
callq 0x5500
jmp 0x213f1
movl $0x0, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jge 0x21422
leaq 0x1f7d9(%rip), %rsi     # 0x40be0
leaq 0x28(%rsp), %rdi
callq 0x5500
jmp 0x21413
jmp 0x21415
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x213f9
leaq 0x1f7c4(%rip), %rsi     # 0x40bed
leaq 0x28(%rsp), %rdi
callq 0x5500
jmp 0x21435
movq 0x2fb7c(%rip), %rdi     # 0x50fb8
leaq 0x28(%rsp), %rsi
callq 0x5220
jmp 0x21448
leaq 0x28(%rsp), %rdi
callq 0x5538
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x54b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/bitboard.h
// Function: east_fill(unsigned long long)
inline
U64 east_fill(U64 gen) 
{
   const U64 pr0 = Not_h_file;
   const U64 pr1 = pr0 & (pr0 << 1);
   const U64 pr2 = pr1 & (pr1 << 2);
   gen |= pr0 & (gen  << 1);
   gen |= pr1 & (gen  << 2);
   gen |= pr2 & (gen  << 4);
   return gen;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movabsq $-0x101010101010102, %rax # imm = 0xFEFEFEFEFEFEFEFE
movq %rax, -0x10(%rsp)
movabsq $-0x303030303030304, %rax # imm = 0xFCFCFCFCFCFCFCFC
movq %rax, -0x18(%rsp)
movabsq $-0xf0f0f0f0f0f0f10, %rax # imm = 0xF0F0F0F0F0F0F0F0
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
shlq %rax
movabsq $-0x101010101010102, %rcx # imm = 0xFEFEFEFEFEFEFEFE
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x2, %rax
movabsq $-0x303030303030304, %rcx # imm = 0xFCFCFCFCFCFCFCFC
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x4, %rax
movabsq $-0xf0f0f0f0f0f0f10, %rcx # imm = 0xF0F0F0F0F0F0F0F0
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/bitboard.h
// Function: west_fill(unsigned long long)
inline
U64 west_fill(U64 gen) 
{
   const U64 pr0 = Not_a_file;
   const U64 pr1 = pr0 & (pr0 >> 1);
   const U64 pr2 = pr1 & (pr1 >> 2);
   gen |= pr0 & (gen >> 1);
   gen |= pr1 & (gen >> 2);
   gen |= pr2 & (gen >> 4);
   return gen;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movabsq $0x7f7f7f7f7f7f7f7f, %rax # imm = 0x7F7F7F7F7F7F7F7F
movq %rax, -0x10(%rsp)
movabsq $0x3f3f3f3f3f3f3f3f, %rax # imm = 0x3F3F3F3F3F3F3F3F
movq %rax, -0x18(%rsp)
movabsq $0xf0f0f0f0f0f0f0f, %rax # imm = 0xF0F0F0F0F0F0F0F
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
shrq %rax
movabsq $0x7f7f7f7f7f7f7f7f, %rcx # imm = 0x7F7F7F7F7F7F7F7F
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x2, %rax
movabsq $0x3f3f3f3f3f3f3f3f, %rcx # imm = 0x3F3F3F3F3F3F3F3F
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x4, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/bitboard.h
// Function: north_fill(unsigned long long)
inline
U64 north_fill(U64 gen) 
{
   gen |= (gen <<  8);
   gen |= (gen << 16);
   gen |= (gen << 32);
   return gen;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x8, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x10, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x20, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: SethKasmann[P]clever-girl/src/bitboard.h
// Function: south_fill(unsigned long long)
inline
U64 south_fill(U64 gen) 
{
   gen |= (gen >>  8);
   gen |= (gen >> 16);
   gen |= (gen >> 32);
   return gen;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x8, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x10, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x20, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: SethKasmann[P]clever-girl/src/bitboard.h
// Function: north_east_fill(unsigned long long)
inline
U64 north_east_fill(U64 gen) 
{
   const U64 pr0 = Not_h_file;
   const U64 pr1 = pr0 & (pr0 <<  9);
   const U64 pr2 = pr1 & (pr1 << 18);
   gen |= pr0 & (gen <<  9);
   gen |= pr1 & (gen << 18);
   gen |= pr2 & (gen << 36);
   return gen;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movabsq $-0x101010101010102, %rax # imm = 0xFEFEFEFEFEFEFEFE
movq %rax, -0x10(%rsp)
movabsq $-0x303030303030400, %rax # imm = 0xFCFCFCFCFCFCFC00
movq %rax, -0x18(%rsp)
movabsq $-0xf0f0f0f10000000, %rax # imm = 0xF0F0F0F0F0000000
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
shlq $0x9, %rax
movabsq $-0x101010101010102, %rcx # imm = 0xFEFEFEFEFEFEFEFE
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x12, %rax
movabsq $-0x303030303030400, %rcx # imm = 0xFCFCFCFCFCFCFC00
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x24, %rax
movabsq $-0xf0f0f0f10000000, %rcx # imm = 0xF0F0F0F0F0000000
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/bitboard.h
// Function: north_west_fill(unsigned long long)
inline
U64 north_west_fill(U64 gen) 
{
   const U64 pr0 = Not_a_file;
   const U64 pr1 = pr0 & (pr0 <<  7);
   const U64 pr2 = pr1 & (pr1 << 14);
   gen |= pr0 & (gen <<  7);
   gen |= pr1 & (gen << 14);
   gen |= pr2 & (gen << 28);
   return gen;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movabsq $0x7f7f7f7f7f7f7f7f, %rax # imm = 0x7F7F7F7F7F7F7F7F
movq %rax, -0x10(%rsp)
movabsq $0x3f3f3f3f3f3f3f00, %rax # imm = 0x3F3F3F3F3F3F3F00
movq %rax, -0x18(%rsp)
movabsq $0xf0f0f0f0f000000, %rax # imm = 0xF0F0F0F0F000000
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
shlq $0x7, %rax
movabsq $0x7f7f7f7f7f7f7f7f, %rcx # imm = 0x7F7F7F7F7F7F7F7F
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0xe, %rax
movabsq $0x3f3f3f3f3f3f3f00, %rcx # imm = 0x3F3F3F3F3F3F3F00
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x1c, %rax
movabsq $0xf0f0f0f0f000000, %rcx # imm = 0xF0F0F0F0F000000
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/bitboard.h
// Function: south_east_fill(unsigned long long)
inline
U64 south_east_fill(U64 gen) 
{
   const U64 pr0 = Not_h_file;
   const U64 pr1 = pr0 & (pr0 >>  7);
   const U64 pr2 = pr1 & (pr1 >> 14);
   gen |= pr0 & (gen >>  7);
   gen |= pr1 & (gen >> 14);
   gen |= pr2 & (gen >> 28);
   return gen;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movabsq $-0x101010101010102, %rax # imm = 0xFEFEFEFEFEFEFEFE
movq %rax, -0x10(%rsp)
movabsq $0xfcfcfcfcfcfcfc, %rax # imm = 0xFCFCFCFCFCFCFC
movq %rax, -0x18(%rsp)
movabsq $0xf0f0f0f0f0, %rax     # imm = 0xF0F0F0F0F0
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
shrq $0x7, %rax
movabsq $-0x101010101010102, %rcx # imm = 0xFEFEFEFEFEFEFEFE
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0xe, %rax
movabsq $0xfcfcfcfcfcfcfc, %rcx # imm = 0xFCFCFCFCFCFCFC
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x1c, %rax
movabsq $0xf0f0f0f0f0, %rcx     # imm = 0xF0F0F0F0F0
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/bitboard.h
// Function: south_west_fill(unsigned long long)
inline
U64 south_west_fill(U64 gen) 
{
   const U64 pr0 = Not_a_file;
   const U64 pr1 = pr0 & (pr0 >>  9);
   const U64 pr2 = pr1 & (pr1 >> 18);
   gen |= pr0 & (gen >>  9);
   gen |= pr1 & (gen >> 18);
   gen |= pr2 & (gen >> 36);
   return gen;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movabsq $0x7f7f7f7f7f7f7f7f, %rax # imm = 0x7F7F7F7F7F7F7F7F
movq %rax, -0x10(%rsp)
movabsq $0x3f3f3f3f3f3f3f, %rax # imm = 0x3F3F3F3F3F3F3F
movq %rax, -0x18(%rsp)
movabsq $0xf0f0f0f0f, %rax      # imm = 0xF0F0F0F0F
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
shrq $0x9, %rax
movabsq $0x7f7f7f7f7f7f7f7f, %rcx # imm = 0x7F7F7F7F7F7F7F7F
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x12, %rax
movabsq $0x3f3f3f3f3f3f3f, %rcx # imm = 0x3F3F3F3F3F3F3F
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x24, %rax
movabsq $0xf0f0f0f0f, %rcx      # imm = 0xF0F0F0F0F
andq %rcx, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/evaluation.cpp
// Function: int Evaluate::outpost<(PieceType)1>(Square, Color)
int Evaluate::outpost(Square p, Color c)
{
    int score;
    // To be an outpost, the piece must be supported by a friendly pawn
    // and unable to be attacked by an opponents pawn.
    if (   !(p & outpost_area[c])
        || !(pawn_attacks[!c][p] & mState.getPieceBB<pawn>(c))
        || in_front[c][p] & adj_files[p] & mState.getPieceBB<pawn>(!c))
        return 0;

    score = PieceSquareTable::outpost[PT == bishop][c][p];

    // Extra bonus if the outpost cannot be captured by a minor piece.
    if (   !mState.getPieceBB<knight>(!c)
        && !(mState.getPieceBB<bishop>(!c) & squares_of_color(p)))
        score *= 2;

    return score;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movl %edx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x44(%rsp), %edi
movl 0x40(%rsp), %eax
movl %eax, %ecx
leaq 0x151734(%rip), %rax    # 0x176710
movq (%rax,%rcx,8), %rsi
callq 0x218d0
cmpq $0x0, %rax
je 0x250a2
movl 0x40(%rsp), %edi
callq 0x24ce0
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x130106(%rip), %rcx    # 0x155110
shlq $0x9, %rdx
addq %rdx, %rcx
movl 0x44(%rsp), %edx
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rdi
movl 0x40(%rsp), %esi
callq 0x24b80
movq %rax, %rcx
movq 0x28(%rsp), %rax
andq %rcx, %rax
cmpq $0x0, %rax
je 0x250a2
movq 0x30(%rsp), %rax
movl 0x40(%rsp), %ecx
movl %ecx, %edx
leaq 0x150ec2(%rip), %rcx    # 0x175f10
shlq $0x9, %rdx
addq %rdx, %rcx
movl 0x44(%rsp), %edx
movq (%rcx,%rdx,8), %rcx
movl 0x44(%rsp), %edx
movl %edx, %esi
leaq 0x150ca6(%rip), %rdx    # 0x175d10
andq (%rdx,%rsi,8), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x40(%rsp), %edi
callq 0x24ce0
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x24b80
movq %rax, %rcx
movq 0x20(%rsp), %rax
andq %rcx, %rax
cmpq $0x0, %rax
je 0x250af
movl $0x0, 0x54(%rsp)
jmp 0x25149
movq 0x30(%rsp), %rax
movl 0x40(%rsp), %ecx
movl %ecx, %edx
leaq 0x1c31f(%rip), %rcx     # 0x413e0
shlq $0x8, %rdx
addq %rdx, %rcx
movl 0x44(%rsp), %edx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x3c(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x40(%rsp), %edi
callq 0x24ce0
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x25bb0
cmpq $0x0, %rax
jne 0x25141
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movl 0x40(%rsp), %edi
callq 0x24ce0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x25bf0
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %edi
callq 0x25400
movq %rax, %rcx
movq 0x8(%rsp), %rax
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x25141
movl 0x3c(%rsp), %eax
shll %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)