LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_return::dump(std::ostream&, int)
void AST_return::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    if ( expr ){
        strm << "Return [" << types.types[expr->type]->name << "]" << endl;
        expr->dump(strm, indentation+1);
    } else {
        strm << "Empty return" << endl;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x3, %edi
callq 0x1fc70
movq 0x10(%rsp), %rdi
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x48167(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x78a0
movq 0x18(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0xa5d8
movq 0x28(%rsp), %rdi
leaq 0x480e0(%rip), %rsi     # 0x52647
callq 0x6370
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x78(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x63f58(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x47a95(%rip), %rsi     # 0x5203d
callq 0x6370
movq %rax, %rdi
movq 0x639e1(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x18(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
addl $0x1, %edx
movq (%rdi), %rax
callq *(%rax)
jmp 0xa5f8
movq 0x28(%rsp), %rdi
leaq 0x4806c(%rip), %rsi     # 0x52650
callq 0x6370
movq %rax, %rdi
movq 0x639a5(%rip), %rsi     # 0x6df98
callq 0x63d0
addq $0x38, %rsp
retq
nopl (%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_conditional::dump(std::ostream&, int, bool)
void AST_conditional::dump(ostream &strm, int indentation, bool first){
    
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    if ( first ){
        strm << "If" << endl;
    } else if ( expr ){
        strm << "Else If" << endl;
    } else {
        strm << "Else" << endl;
    }

    dump_indentation(strm, indentation+1);
    strm << "     (" << endl;
    
    if ( expr ){
        expr->dump(strm, indentation+1);
    }
    
    dump_indentation(strm, indentation+1);
    strm << "     )" << endl;
    
    blck->dump(strm, indentation+1);
    
    if ( else_if ){
        else_if->dump(strm, indentation, false);
    }
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
andb $0x1, %al
movb %al, 0x23(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x3, %edi
callq 0x1fc70
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x4803f(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x78a0
testb $0x1, 0x23(%rsp)
je 0xa6a0
movq 0x28(%rsp), %rdi
leaq 0x47fd8(%rip), %rsi     # 0x52662
callq 0x6370
movq %rax, %rdi
movq 0x638ff(%rip), %rsi     # 0x6df98
callq 0x63d0
jmp 0xa6f0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0xa6ce
movq 0x28(%rsp), %rdi
leaq 0x47fa5(%rip), %rsi     # 0x5265d
callq 0x6370
movq %rax, %rdi
movq 0x638d1(%rip), %rsi     # 0x6df98
callq 0x63d0
jmp 0xa6ee
movq 0x28(%rsp), %rdi
leaq 0x47f8b(%rip), %rsi     # 0x52665
callq 0x6370
movq %rax, %rdi
movq 0x638af(%rip), %rsi     # 0x6df98
callq 0x63d0
jmp 0xa6f0
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
addl $0x1, %esi
callq 0x78a0
movq 0x28(%rsp), %rdi
leaq 0x47dca(%rip), %rsi     # 0x524d7
callq 0x6370
movq %rax, %rdi
movq 0x6387c(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0xa747
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
addl $0x1, %edx
movq (%rdi), %rax
callq *(%rax)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
addl $0x1, %esi
callq 0x78a0
movq 0x28(%rsp), %rdi
leaq 0x47d7b(%rip), %rsi     # 0x524df
callq 0x6370
movq %rax, %rdi
movq 0x63825(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
addl $0x1, %edx
movq (%rdi), %rax
callq *(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0xa7c1
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movq (%rdi), %rax
xorl %ecx, %ecx
callq *0x18(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_loop::dump(std::ostream&, int)
void AST_loop::dump(ostream &strm, int indentation){
    
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    strm << "While" << endl;
    
    dump_indentation(strm, indentation+1);
    strm << "     (" << endl;
    
    if ( expr ){
        expr->dump(strm, indentation+1);
    }
    
    dump_indentation(strm, indentation+1);
    strm << "     )" << endl;
    
    blck->dump(strm, indentation+1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl $0x3, %edi
callq 0x1fc70
movq (%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x47e79(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x78a0
movq 0x18(%rsp), %rdi
leaq 0x47e21(%rip), %rsi     # 0x5266a
callq 0x6370
movq %rax, %rdi
movq 0x63740(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
addl $0x1, %esi
callq 0x78a0
movq 0x18(%rsp), %rdi
leaq 0x47c5d(%rip), %rsi     # 0x524d7
callq 0x6370
movq %rax, %rdi
movq 0x6370f(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0xa8b4
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
addl $0x1, %edx
movq (%rdi), %rax
callq *(%rax)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
addl $0x1, %esi
callq 0x78a0
movq 0x18(%rsp), %rdi
leaq 0x47c0e(%rip), %rsi     # 0x524df
callq 0x6370
movq %rax, %rdi
movq 0x636b8(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
addl $0x1, %edx
movq (%rdi), %rax
callq *(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_bounded_loop::dump(std::ostream&, int)
void AST_bounded_loop::dump(ostream &strm, int indentation){
    
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    strm << "For " << name << " in" << endl;
    
    dump_indentation(strm, indentation+1);
    strm << "     (" << endl;
    
    if (0 != left_bound) {
        left_bound->dump(strm, indentation+2);
    }
    
    dump_indentation(strm, indentation+1);
    strm << "     ," << endl;
    
    if (0 != right_bound) {
        right_bound->dump(strm, indentation+2);
    }
    
    dump_indentation(strm, indentation+1);
    strm << "     )" << endl;
    
    blck->dump(strm, indentation+1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl $0x3, %edi
callq 0x1fc70
movq (%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x47d39(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x78a0
movq 0x18(%rsp), %rdi
leaq 0x47ce7(%rip), %rsi     # 0x52670
callq 0x6370
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0x78, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x47ccc(%rip), %rsi     # 0x52675
callq 0x6370
movq %rax, %rdi
movq 0x635e0(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
addl $0x1, %esi
callq 0x78a0
movq 0x18(%rsp), %rdi
leaq 0x47afd(%rip), %rsi     # 0x524d7
callq 0x6370
movq %rax, %rdi
movq 0x635af(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0xa8(%rcx), %rax
je 0xaa1b
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
addl $0x2, %edx
movq (%rdi), %rax
callq *(%rax)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
addl $0x1, %esi
callq 0x78a0
movq 0x18(%rsp), %rdi
leaq 0x47c41(%rip), %rsi     # 0x52679
callq 0x6370
movq %rax, %rdi
movq 0x63551(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0xb0(%rcx), %rax
je 0xaa79
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
addl $0x2, %edx
movq (%rdi), %rax
callq *(%rax)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
addl $0x1, %esi
callq 0x78a0
movq 0x18(%rsp), %rdi
leaq 0x47a49(%rip), %rsi     # 0x524df
callq 0x6370
movq %rax, %rdi
movq 0x634f3(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x8(%rsp), %rax
movq 0xb8(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
addl $0x1, %edx
movq (%rdi), %rax
callq *(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_read::dump(std::ostream&, int)
void AST_read::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    strm << "Read " << variable;
    
    if ( sym ){
        strm << " ["
             << types.types[sym->getType()]->name
             << ":"
             << sym->getLine()
             << ":"
             << sym->getColumn()
             << "]";
    } else {
        strm << " [UNDEFINED]";
    }
    strm << endl;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x3, %edi
callq 0x1fc70
movq 0x20(%rsp), %rdi
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x47b77(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x78a0
movq 0x38(%rsp), %rdi
leaq 0x47b35(%rip), %rsi     # 0x52680
callq 0x6370
movq 0x28(%rsp), %rsi
movq %rax, %rdi
addq $0x78, %rsi
callq 0x6340
movq 0x28(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0xac37
movq 0x38(%rsp), %rdi
leaq 0x479c3(%rip), %rsi     # 0x52543
callq 0x6370
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x98(%rax), %rdi
callq 0x295f0
movslq %eax, %rsi
leaq 0x63938(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x49712(%rip), %rsi     # 0x542da
callq 0x6370
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x98(%rax), %rdi
callq 0x29600
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x6690
movq %rax, %rdi
leaq 0x496de(%rip), %rsi     # 0x542da
callq 0x6370
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x98(%rax), %rdi
callq 0x29610
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x6690
movq %rax, %rdi
leaq 0x4740d(%rip), %rsi     # 0x5203d
callq 0x6370
jmp 0xac48
movq 0x38(%rsp), %rdi
leaq 0x479b2(%rip), %rsi     # 0x525f5
callq 0x6370
movq 0x38(%rsp), %rdi
movq 0x63344(%rip), %rsi     # 0x6df98
callq 0x63d0
addq $0x48, %rsp
retq
nop
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_print::dump(std::ostream&, int)
void AST_print::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    strm << "Print" << endl;
    vector<AST_expression*>::iterator it;
    for (it=list.begin(); it!=list.end(); ++it){
        
        if ( it != list.begin() ){
            dump_indentation(strm, indentation+1);
            strm << "     ," << endl;
        }
        
        (*it)->dump(strm, indentation+1);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl $0x3, %edi
callq 0x1fc70
movq (%rsp), %rdi
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x479e9(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x78a0
movq 0x38(%rsp), %rdi
leaq 0x479ad(%rip), %rsi     # 0x52686
callq 0x6370
movq %rax, %rdi
movq 0x632b0(%rip), %rsi     # 0x6df98
callq 0x63d0
leaq 0x28(%rsp), %rdi
callq 0x20050
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
callq 0x20070
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
callq 0x200e0
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x200a0
testb $0x1, %al
jne 0xad3f
jmp 0xadc5
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
callq 0x20070
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x200a0
testb $0x1, %al
jne 0xad67
jmp 0xad98
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
addl $0x1, %esi
callq 0x78a0
movq 0x38(%rsp), %rdi
leaq 0x478f5(%rip), %rsi     # 0x52679
callq 0x6370
movq %rax, %rdi
movq 0x63205(%rip), %rsi     # 0x6df98
callq 0x63d0
leaq 0x28(%rsp), %rdi
callq 0x20110
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
addl $0x1, %edx
movq (%rdi), %rax
callq *(%rax)
leaq 0x28(%rsp), %rdi
callq 0x20120
jmp 0xad14
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_fill::dump(std::ostream&, int)
void AST_fill::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    strm << "Fill" << endl;
    expr->dump(strm, indentation+1);
    
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    strm << "With " << function << endl;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0x3, %edi
callq 0x1fc70
movq (%rsp), %rdi
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x47879(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x78a0
movq 0x28(%rsp), %rdi
leaq 0x47843(%rip), %rsi     # 0x5268c
callq 0x6370
movq %rax, %rdi
movq 0x63140(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
addl $0x1, %edx
movq (%rdi), %rax
callq *(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x3, %edi
callq 0x1fc70
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x477ec(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x78a0
movq 0x28(%rsp), %rdi
leaq 0x477bb(%rip), %rsi     # 0x52691
callq 0x6370
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x80, %rsi
callq 0x6340
movq %rax, %rdi
movq 0x6309f(%rip), %rsi     # 0x6df98
callq 0x63d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_map::dump(std::ostream&, int)
void AST_map::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    strm << "Map (" << function << ")" <<endl;
    
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << "Source: ";
    src->dump(strm, indentation+1);
    
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << "Destination: ";
    dst->dump(strm, indentation+1);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x3, %edi
callq 0x1fc70
movq 0x8(%rsp), %rdi
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x47737(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x78a0
movq 0x38(%rsp), %rdi
leaq 0x4770c(%rip), %rsi     # 0x52697
callq 0x6370
movq 0x20(%rsp), %rsi
movq %rax, %rdi
addq $0x88, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x47536(%rip), %rsi     # 0x524e4
callq 0x6370
movq %rax, %rdi
movq 0x62fdb(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x3, %edi
callq 0x1fc70
movq 0x10(%rsp), %rdi
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x476a1(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x78a0
movq 0x38(%rsp), %rdi
leaq 0x4767c(%rip), %rsi     # 0x5269d
callq 0x6370
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
addl $0x1, %edx
movq (%rdi), %rax
callq *(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x3, %edi
callq 0x1fc70
movq 0x18(%rsp), %rdi
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %esi
callq 0x6450
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x47623(%rip), %rsi     # 0x526a3
callq 0x6370
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x78a0
movq 0x38(%rsp), %rdi
leaq 0x47607(%rip), %rsi     # 0x526a6
callq 0x6370
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
addl $0x1, %edx
movq (%rdi), %rax
callq *(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_enum_constant::fill_and_check(symbol_table*)
void AST_enum_constant::fill_and_check(symbol_table* st){
    for (vector< type_descriptor* >::iterator it = types.types.begin(); it != types.types.end(); ++ it) {
        if (typeid(**it) != typeid(enum_type)) {
            continue;
        }
        set<string> *e = ((enum_type*)(*it))->values;
        enum_index = 0;
        set<string>::iterator ite;
        for (ite = e->begin(); ite != e->end(); ++ ite) {
            if (!value.compare(*ite)) {
                break;
            }
            ++ enum_index;
        }
        if (ite != e->end()) {
            break;
        }
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x62471(%rip), %rdi     # 0x6e4e0
callq 0x20140
movq %rax, 0x50(%rsp)
leaq 0x62460(%rip), %rdi     # 0x6e4e0
callq 0x201b0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x20170
testb $0x1, %al
jne 0xc0a2
jmp 0xc1cb
leaq 0x50(%rsp), %rdi
callq 0x201e0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0xc0bf
callq 0x6420
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x61b96(%rip), %rsi     # 0x6dc68
callq 0x201f0
testb $0x1, %al
jne 0xc0dd
jmp 0xc0e2
jmp 0xc1bc
leaq 0x50(%rsp), %rdi
callq 0x201e0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq (%rcx), %rcx
movq 0x38(%rcx), %rcx
movq %rcx, 0x40(%rsp)
movl $0x0, 0x68(%rax)
leaq 0x38(%rsp), %rdi
callq 0x20220
movq 0x40(%rsp), %rdi
callq 0x20240
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x20290
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x20270
testb $0x1, %al
jne 0xc14e
jmp 0xc194
movq 0x18(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x202c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6050
cmpl $0x0, %eax
jne 0xc17a
jmp 0xc194
movq 0x18(%rsp), %rax
movl 0x68(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x68(%rax)
leaq 0x38(%rsp), %rdi
callq 0x202f0
jmp 0xc12a
movq 0x40(%rsp), %rdi
callq 0x20290
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x20270
testb $0x1, %al
jne 0xc1b8
jmp 0xc1ba
jmp 0xc1cb
jmp 0xc1bc
leaq 0x50(%rsp), %rdi
callq 0x20320
jmp 0xc079
addq $0x68, %rsp
retq
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_dereference::fill_and_check(symbol_table*, bool)
void AST_dereference::fill_and_check(symbol_table* st, bool lval){
    value->fill_and_check(st, lval);
    
    type_descriptor* td = types.types[value->type];
    
    if ( typeid(*td) == typeid(pointer_descriptor) ){
        type = ((pointer_descriptor*)td)->base;
    } else {
        type = INVALID;
    }
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rax), %rdi
movq 0x28(%rsp), %rsi
movb 0x27(%rsp), %cl
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %edx
callq *0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x61b23(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0xc9df
callq 0x6420
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x604e6(%rip), %rsi     # 0x6ced8
callq 0x20340
testb $0x1, %al
jne 0xc9fd
jmp 0xca0f
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, 0x10(%rax)
jmp 0xca1b
movq 0x8(%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x38, %rsp
retq
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_array_access::fill_and_check(symbol_table*, bool)
void AST_array_access::fill_and_check(symbol_table* st, bool lval){
    
    //en caso de haber un error de sintáxis con recuperación de errores puede no haber valor
    if ( !value )
        return;
    
    value->fill_and_check(st, lval);
    
    if ( typeid(*(types.types[ value->type ])) != typeid(array_descriptor) ){
        logger->buf << "Intento de acceso indexado a tipo '"
                    << types.types[value->type]->name << "'.";
        logger->error(line, column);
        type = INVALID;
    } else {
        type = ((array_descriptor*)types.types[ value->type ])->base;
    }
    
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x48(%rax)
jne 0xccec
jmp 0xce08
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x28(%rsp), %rsi
movb 0x27(%rsp), %cl
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %edx
callq *0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x617c2(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0xcd36
callq 0x6420
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x60177(%rip), %rsi     # 0x6cec0
callq 0x201f0
testb $0x1, %al
jne 0xcd57
jmp 0xcdde
leaq 0x6177a(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x45bbd(%rip), %rsi     # 0x5292d
callq 0x6370
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x48(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x6174f(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x4a906(%rip), %rsi     # 0x576b7
callq 0x6370
movq 0x18(%rsp), %rax
leaq 0x61716(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
movq 0x18(%rsp), %rax
movl $0x1, 0x10(%rax)
jmp 0xce08
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x616ee(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq (%rcx), %rcx
movl 0x3c(%rcx), %ecx
movl %ecx, 0x10(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_conversion::fill_and_check(symbol_table*)
void AST_conversion::fill_and_check(symbol_table* st){
    expr->fill_and_check(st);
    original_type = expr->type;
    if (!types.is_base(original_type) || !types.is_base(type) || STRING == original_type || STRING == type) {
        logger->buf << "Conversión permitida sólo entre tipos primitivos ('"
                    << types.types[original_type]->name << "' a '"
                    << types.types[type]->name << "'.";
        logger->error(line, column);
        type = INVALID;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x48(%rax)
movl 0x48(%rax), %esi
leaq 0x61190(%rip), %rdi     # 0x6e4e0
callq 0x2d9f0
testb $0x1, %al
jne 0xd35b
jmp 0xd397
movq 0x10(%rsp), %rax
movl 0x10(%rax), %esi
leaq 0x61176(%rip), %rdi     # 0x6e4e0
callq 0x2d9f0
testb $0x1, %al
jne 0xd375
jmp 0xd397
movq 0x10(%rsp), %rcx
movl $0x7, %eax
cmpl 0x48(%rcx), %eax
je 0xd397
movq 0x10(%rsp), %rcx
movl $0x7, %eax
cmpl 0x10(%rcx), %eax
jne 0xd453
leaq 0x6113a(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x455df(%rip), %rsi     # 0x5298f
callq 0x6370
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rsp)
movslq 0x48(%rax), %rsi
leaq 0x61114(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq (%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x455da(%rip), %rsi     # 0x529c5
callq 0x6370
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movslq 0x10(%rax), %rsi
leaq 0x610d8(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x4a28f(%rip), %rsi     # 0x576b7
callq 0x6370
movq 0x10(%rsp), %rax
leaq 0x6109f(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
movq 0x10(%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_block::fill_and_check(symbol_table*)
void AST_block::fill_and_check(symbol_table* st){
    
    /* Verificar cada statement del bloque, se asume que la tabla de
     * simbolos es nueva o que tiene los argumentos de la funcion en caso
     * de ser el cuerpo de una
     */
    vector<AST_statement*>::iterator it;
    
    for (vector<AST_statement*>::iterator it = statements.begin();
         it != statements.end(); ++ it)
     {
        if ( typeid(**it) == typeid(AST_block) ){
            symbol_table* nested_block = st->new_son();
            (*it)->fill_and_check(nested_block);
            delete nested_block;
        } else {
            (*it)->fill_and_check(st);
        }
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1fe80
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
callq 0x1fea0
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
callq 0x1ff10
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1fed0
testb $0x1, %al
jne 0xd4c6
jmp 0xd579
leaq 0x28(%rsp), %rdi
callq 0x1ff40
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0xd4e3
callq 0x6420
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x5fa42(%rip), %rsi     # 0x6cf38
callq 0x20340
testb $0x1, %al
jne 0xd501
jmp 0xd550
movq 0x38(%rsp), %rdi
callq 0x2a330
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1ff40
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xd54e
movq (%rsp), %rdi
callq 0x203d0
movq (%rsp), %rdi
movl $0x48, %esi
callq 0x63a0
jmp 0xd568
leaq 0x28(%rsp), %rdi
callq 0x1ff40
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xd56a
leaq 0x28(%rsp), %rdi
callq 0x1ff50
jmp 0xd498
addq $0x48, %rsp
retq
nop
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_parameters_list::fill_and_check(symbol_table*, std::vector<bool, std::allocator<bool>>&)
void AST_parameters_list::fill_and_check(symbol_table* st,
                                         vector<bool>& constant)
{
    /* Verifica el tipo de cada uno de los parametros reales de la llamada de
     * una funcion
     */
    for (vector<AST_expression*>::iterator it=elem.begin(); it != elem.end(); ++it){
        if (0 != *it) {
            (*it)->fill_and_check(st);
            (*it)->check_call(st);
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0x20070
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x200e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x200a0
testb $0x1, %al
jne 0xd5d3
jmp 0xd625
leaq 0x18(%rsp), %rdi
callq 0x20110
movq %rax, %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0xd617
leaq 0x18(%rsp), %rdi
callq 0x20110
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x20110
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0xd619
leaq 0x18(%rsp), %rdi
callq 0x20120
jmp 0xd5ab
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_parameters_list::fill_and_check(symbol_table*)
void AST_parameters_list::fill_and_check(symbol_table* st){
    
    /* Verifica el tipo de cada uno de los parametros reales de la llamada de
     * una funcion
     */
    for (vector<AST_expression*>::iterator it=elem.begin(); it != elem.end(); ++it){
        if (0 != *it) {
            (*it)->fill_and_check(st);
            (*it)->check_call(st);
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x10, %rdi
callq 0x20070
movq %rax, 0x10(%rsp)
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x200e0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x200a0
testb $0x1, %al
jne 0xd67c
jmp 0xd6ce
leaq 0x10(%rsp), %rdi
callq 0x20110
movq %rax, %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0xd6c0
leaq 0x10(%rsp), %rdi
callq 0x20110
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x20110
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0xd6c2
leaq 0x10(%rsp), %rdi
callq 0x20120
jmp 0xd655
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_arg_list::fill_and_check(symbol_table*)
void AST_arg_list::fill_and_check(symbol_table* st){
    
    for ( vector<symbol*>::iterator it =args.begin(); it != args.end(); ++it){
        
        int level = 0;
        symbol* prev = st->lookup( (*it)->getName(), &level );
        if ( prev ){
            if ( level != 0 ){
                st->insert( (*it) );
            } else {
                logger->buf << "Argumento '" << (*it)->getName() << "' con identificador repetido.";
                logger->error(line, column);

                break;
            }
        } else {
            st->insert( (*it) );
        }
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x10, %rdi
callq 0x1fd30
movq %rax, 0xb0(%rsp)
movq 0x40(%rsp), %rdi
addq $0x10, %rdi
callq 0x1fda0
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x1fd60
testb $0x1, %al
jne 0xe4e9
jmp 0xe699
movl $0x0, 0xa4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x1fdd0
movq (%rax), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x295b0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0xa4(%rsp), %rdx
callq 0x2a040
movq %rax, 0x38(%rsp)
jmp 0xe53e
leaq 0x78(%rsp), %rdi
callq 0x6778
movq 0x38(%rsp), %rax
movq %rax, 0x98(%rsp)
cmpq $0x0, 0x98(%rsp)
je 0xe660
cmpl $0x0, 0xa4(%rsp)
je 0xe5b7
movq 0xb8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x1fdd0
movq 0x20(%rsp), %rdi
movq (%rax), %rsi
callq 0x2a1f0
jmp 0xe65e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x6778
jmp 0xe6a1
leaq 0x5ff1a(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x4452c(%rip), %rsi     # 0x52af8
callq 0x6370
movq %rax, 0x8(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x1fdd0
movq (%rax), %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x295b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6340
movq %rax, 0x18(%rsp)
jmp 0xe60b
movq 0x18(%rsp), %rdi
leaq 0x444ed(%rip), %rsi     # 0x52b04
callq 0x6370
jmp 0xe61e
leaq 0x48(%rsp), %rdi
callq 0x6778
movq 0x40(%rsp), %rax
leaq 0x5fea4(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xe699
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6778
jmp 0xe6a1
jmp 0xe685
movq 0xb8(%rsp), %rax
movq %rax, (%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x1fdd0
movq (%rsp), %rdi
movq (%rax), %rsi
callq 0x2a1f0
jmp 0xe687
leaq 0xb0(%rsp), %rdi
callq 0x1fde0
jmp 0xe4b5
addq $0xc8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x66b0
nopl (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_function::fill_and_check(symbol_table*)
void AST_function::fill_and_check(symbol_table* st){
    
    symbol_table* nested_block = st->new_son();
    
    expected_return = func->getType();
    formal_parameters->fill_and_check(nested_block);
    instructions->fill_and_check(nested_block);
    
    expected_return = UNDEFINED;
    
    delete nested_block;
    
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x2a330
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x98(%rax), %rdi
callq 0x295f0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x5f94f(%rip)     # 0x6e3e4
movq 0xa0(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rax
movq 0xa8(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, 0x5f91d(%rip)     # 0x6e3e4
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xeaf0
movq 0x8(%rsp), %rdi
callq 0x203d0
movq 0x8(%rsp), %rdi
movl $0x48, %esi
callq 0x63a0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_assignment::fill_and_check(symbol_table*)
void AST_assignment::fill_and_check(symbol_table* st){
    
    lvalue->fill_and_check(st, true);
    if (0 != expr) {
        expr->fill_and_check(st);
    }
    
    if ( 0 != expr && expr->type != lvalue->type
                && expr->type != INVALID 
                && lvalue->type != INVALID
                && expr->type != UNDEFINED
                && lvalue->type != UNDEFINED
              )
    {
        logger->buf << "Intento de asignación de tipo '"
                    << types.types[expr->type]->name << "' a variable de tipo '"
                    << types.types[lvalue->type]->name << "'.";
        logger->error(line, column);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x10(%rax)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x80(%rcx), %rax
je 0xf2b3
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x80(%rcx), %rax
je 0xf3f0
movq 0x10(%rsp), %rcx
movq 0x80(%rcx), %rax
movl 0x10(%rax), %eax
movq 0x78(%rcx), %rcx
cmpl 0x10(%rcx), %eax
je 0xf3f0
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rax
cmpl $0x1, 0x10(%rax)
je 0xf3f0
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rax
cmpl $0x1, 0x10(%rax)
je 0xf3f0
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0xf3f0
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0xf3f0
leaq 0x5f19c(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x438c6(%rip), %rsi     # 0x52c14
callq 0x6370
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rsp)
movq 0x80(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x5f16f(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq (%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x438a5(%rip), %rsi     # 0x52c35
callq 0x6370
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x78(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x5f12f(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x482e6(%rip), %rsi     # 0x576b7
callq 0x6370
movq 0x10(%rsp), %rax
leaq 0x5f0f6(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_conditional::fill_and_check(symbol_table*)
void AST_conditional::fill_and_check(symbol_table* st){
    
    if ( expr ){
        expr->fill_and_check(st);
        
        if ( expr->type != BOOLEAN ){
            logger->buf << "Se esperaba boolean.";
            logger->error(expr->line, expr->column);
        }
    }
    
    symbol_table* nested_block = st->new_son();
    blck->fill_and_check(nested_block);
    
    delete nested_block;
    
    if ( else_if ){
        else_if->fill_and_check(st);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x78(%rax)
je 0xf6c4
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rax
cmpl $0x6, 0x10(%rax)
je 0xf6c2
leaq 0x5ee4f(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x43602(%rip), %rsi     # 0x52c9d
callq 0x6370
movq 0x8(%rsp), %rax
leaq 0x5ee2c(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movq 0x78(%rax), %rcx
movl 0x8(%rcx), %esi
movq 0x78(%rax), %rax
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xf6c4
movq 0x18(%rsp), %rdi
callq 0x2a330
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x80(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xf713
movq (%rsp), %rdi
callq 0x203d0
movq (%rsp), %rdi
movl $0x48, %esi
callq 0x63a0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0xf739
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x28, %rsp
retq
nop
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_loop::fill_and_check(symbol_table*)
void AST_loop::fill_and_check(symbol_table* st){
    if (0 != expr) {
        expr->fill_and_check(st);
        if ( expr->type != INVALID && expr->type != BOOLEAN ){
            logger->buf << "Se esperaba boolean.";
            logger->error(line, column);
        }
    }
    
    symbol_table* nested_block = st->new_son();
    blck->fill_and_check(nested_block);
    delete nested_block;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x78(%rcx), %rax
je 0xf7cc
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rax
cmpl $0x1, 0x10(%rax)
je 0xf7ca
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rax
cmpl $0x6, 0x10(%rax)
je 0xf7ca
leaq 0x5ed3f(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x434f2(%rip), %rsi     # 0x52c9d
callq 0x6370
movq 0x8(%rsp), %rax
leaq 0x5ed1c(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xf7cc
movq 0x18(%rsp), %rdi
callq 0x2a330
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x80(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xf81b
movq (%rsp), %rdi
callq 0x203d0
movq (%rsp), %rdi
movl $0x48, %esi
callq 0x63a0
addq $0x28, %rsp
retq
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_un_op::to_tac(Tac*)
opd *AST_un_op::to_tac(Tac* t){
    opd* e = expr->to_tac(t);
    
    switch( oper_type ){
        case NOT:
            falselist = expr->truelist;
            truelist  = expr->falselist;
            break;
        default:
            {
                opd* d = new opd();
                t->append_quad(inst::UMINUS, d, e, 0, "operación binaria de inverso");
                
                return d;
            }
            break;
    }
    return 0;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rax), %rdi
movq 0x80(%rsp), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x78(%rsp)
movl 0x48(%rax), %eax
subl $0x1, %eax
jne 0x15cc1
jmp 0x15c90
movq 0x30(%rsp), %rdi
movq 0x50(%rdi), %rsi
addq $0x18, %rsi
addq $0x30, %rdi
callq 0x208f0
movq 0x30(%rsp), %rdi
movq 0x50(%rdi), %rsi
addq $0x30, %rsi
addq $0x18, %rdi
callq 0x208f0
jmp 0x15dca
movl $0x18, %edi
callq 0x6390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
callq 0x37ff0
jmp 0x15cdd
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x66c0
movq 0x20(%rsp), %rdx
leaq 0x3d752(%rip), %rsi     # 0x53475
leaq 0x40(%rsp), %rdi
callq 0x7500
jmp 0x15d2f
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movl $0x15, %esi
leaq 0x40(%rsp), %r9
callq 0x4de80
jmp 0x15d54
leaq 0x40(%rsp), %rdi
callq 0x6778
leaq 0x3f(%rsp), %rdi
callq 0x6400
movq 0x70(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x15dd6
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
movl $0x18, %esi
callq 0x63a0
jmp 0x15de6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x15dbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x6778
leaq 0x3f(%rsp), %rdi
callq 0x6400
jmp 0x15de6
movq $0x0, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x66b0
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_boolean::to_tac(Tac*)
opd *AST_boolean::to_tac(Tac* t){
    if ( value ){
        truelist.clear();
        truelist.push_back(t->next_instruction());
    } else {
        falselist.clear();
        falselist.push_back(t->next_instruction());
    }
    t->append_quad(inst::GOTO, 0, 0, 0, "salto condicional de booleano");
    return 0;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
testb $0x1, 0x48(%rax)
je 0x16309
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x20ad0
movq 0x20(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
callq 0x4dfb0
movq 0x18(%rsp), %rdi
movl %eax, 0x64(%rsp)
leaq 0x64(%rsp), %rsi
callq 0x20950
jmp 0x16342
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
callq 0x20ad0
movq 0x20(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
callq 0x4dfb0
movq 0x10(%rsp), %rdi
movl %eax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x20950
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x66c0
movq 0x8(%rsp), %rdx
leaq 0x3d15a(%rip), %rsi     # 0x534c0
leaq 0x40(%rsp), %rdi
callq 0x7500
jmp 0x16372
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movl $0x16, %esi
leaq 0x40(%rsp), %r9
movq %r8, %rdx
movq %r8, %rcx
callq 0x4de80
jmp 0x16392
leaq 0x40(%rsp), %rdi
callq 0x6778
leaq 0x3f(%rsp), %rdi
callq 0x6400
xorl %eax, %eax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x163d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x6778
leaq 0x3f(%rsp), %rdi
callq 0x6400
movq 0x30(%rsp), %rdi
callq 0x66b0
nopl (%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_lval::gen_tac_lval_disp(Tac*, opd*, int*)
opd *AST_lval::gen_tac_lval_disp(Tac* t, opd *din_base, int *sta_base){
    opd *o;
    if (0 != *sta_base) {
        o = new opd();
        t->append_quad(inst::ADD, o, din_base, new opd(*sta_base), "sumar base estática a base dinámica (no se pudo retrasar más la suma)");
    } else {
        o = din_base;
    }
    return o;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x70(%rsp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x165a9
movl $0x18, %edi
callq 0x6390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
callq 0x37ff0
jmp 0x16484
movq 0x28(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x18, %edi
callq 0x6390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rax
movl (%rax), %esi
movl $0x2, %edx
callq 0x38010
jmp 0x164d7
leaq 0x37(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x66c0
movq (%rsp), %rdx
leaq 0x3d030(%rip), %rsi     # 0x53520
leaq 0x38(%rsp), %rdi
callq 0x7500
jmp 0x164fc
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
movl $0x11, %esi
leaq 0x38(%rsp), %r9
callq 0x4de80
jmp 0x16521
leaq 0x38(%rsp), %rdi
callq 0x6778
leaq 0x37(%rsp), %rdi
callq 0x6400
jmp 0x165b3
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl $0x18, %esi
callq 0x63a0
jmp 0x165c0
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl $0x18, %esi
callq 0x63a0
jmp 0x165c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1659d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6778
leaq 0x37(%rsp), %rdi
callq 0x6400
jmp 0x165c0
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x66b0
nopw (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_dereference::gen_tac_lval(Tac*, int*)
opd *AST_dereference::gen_tac_lval(Tac* t, int *sta_base){
    opd *o = value->gen_tac_lval(t, sta_base), *d = new opd();
    o = gen_tac_lval_disp(t, o, sta_base);
    t->append_quad(inst::DEREF, d, o, 0, "dereferenciar un lvalue");
    return d;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, 0x68(%rsp)
movl $0x18, %edi
callq 0x6390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
callq 0x37ff0
jmp 0x16749
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x78(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x16440
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x66c0
movq 0x18(%rsp), %rdx
leaq 0x3cdc5(%rip), %rsi     # 0x53569
leaq 0x30(%rsp), %rdi
callq 0x7500
jmp 0x167b0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movl $0x4, %esi
leaq 0x30(%rsp), %r9
callq 0x4de80
jmp 0x167d4
leaq 0x30(%rsp), %rdi
callq 0x6778
leaq 0x2f(%rsp), %rdi
callq 0x6400
movq 0x60(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x18, %esi
callq 0x63a0
jmp 0x16846
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1683c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6778
leaq 0x2f(%rsp), %rdi
callq 0x6400
movq 0x58(%rsp), %rdi
callq 0x66b0