LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsi,%rax)
movl 0x8(%rdi), %esi
movq %r14, %rdi
callq 0x6540
leaq 0x241ba(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
testl %ebx, %ebx
jle 0x952d
leaq 0x2623c(%rip), %r12     # 0x2f751
movl %ebx, %r13d
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6370
decl %r13d
jne 0x9518
testb %bpl, %bpl
je 0x9540
leaq 0x2413d(%rip), %rsi     # 0x2d676
movl $0x2, %edx
jmp 0x9561
cmpq $0x0, 0x78(%r15)
je 0x9555
leaq 0x24123(%rip), %rsi     # 0x2d671
movl $0x7, %edx
jmp 0x9561
leaq 0x2411d(%rip), %rsi     # 0x2d679
movl $0x4, %edx
movq %r14, %rdi
callq 0x6370
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
testl %ebx, %ebx
js 0x95b2
leal 0x1(%rbx), %ebp
leaq 0x261b3(%rip), %r12     # 0x2f751
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6370
decl %ebp
jne 0x959e
leal 0x1(%rbx), %ebp
leaq 0x23f2f(%rip), %rsi     # 0x2d4eb
movl $0x6, %edx
movq %r14, %rdi
callq 0x6370
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq 0x78(%r15), %rdi
testq %rdi, %rdi
je 0x9603
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *(%rax)
testl %ebx, %ebx
js 0x9626
leaq 0x26143(%rip), %r12     # 0x2f751
movl %ebp, %r13d
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6370
decl %r13d
jne 0x9611
leaq 0x23ec6(%rip), %rsi     # 0x2d4f3
movl $0x6, %edx
movq %r14, %rdi
callq 0x6370
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq 0x80(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *(%rax)
movq 0x88(%r15), %rdi
testq %rdi, %rdi
je 0x969c
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsi,%rax)
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x6540
leaq 0x23fd8(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
testl %r15d, %r15d
jle 0x970f
leaq 0x26059(%rip), %r12     # 0x2f751
movl %r15d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6370
decl %ebp
jne 0x96fb
leaq 0x23f68(%rip), %rsi     # 0x2d67e
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
testl %r15d, %r15d
js 0x976e
leal 0x1(%r15), %ebp
leaq 0x25ff7(%rip), %r12     # 0x2f751
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6370
decl %ebp
jne 0x975a
leal 0x1(%r15), %ebp
leaq 0x23d72(%rip), %rsi     # 0x2d4eb
movl $0x6, %edx
movq %rbx, %rdi
callq 0x6370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0x97c0
movq (%rdi), %rax
movq %rbx, %rsi
movl %ebp, %edx
callq *(%rax)
testl %r15d, %r15d
js 0x97e4
leaq 0x25f85(%rip), %r15     # 0x2f751
movl %ebp, %r12d
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6370
decl %r12d
jne 0x97cf
leaq 0x23d08(%rip), %rsi     # 0x2d4f3
movl $0x6, %edx
movq %rbx, %rdi
callq 0x6370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq 0x80(%r14), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsi,%rax)
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x6540
leaq 0x23c1f(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
testl %ebp, %ebp
jle 0x9ac4
leaq 0x25ca1(%rip), %r15     # 0x2f751
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6370
decl %ebp
jne 0x9ab0
leaq 0x23bc9(%rip), %rsi     # 0x2d694
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6370
movq 0x78(%r14), %rsi
movq 0x80(%r14), %rdx
movq %rbx, %rdi
callq 0x6370
cmpq $0x0, 0x98(%r14)
je 0x9ba3
leaq 0x23a57(%rip), %rsi     # 0x2d557
movl $0x2, %edx
movq %rbx, %rdi
callq 0x6370
movq 0x98(%r14), %rdi
callq 0x1801a
cltq
leaq 0x358ee(%rip), %rcx     # 0x3f410
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x6370
movq %rax, %r15
leaq 0x257c7(%rip), %r12     # 0x2f30a
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x6370
movq 0x98(%r14), %rdi
callq 0x1801e
movq %r15, %rdi
movl %eax, %esi
callq 0x6540
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x6370
movq 0x98(%r14), %rdi
callq 0x18022
movq %r15, %rdi
movl %eax, %esi
callq 0x6540
leaq 0x234a4(%rip), %rsi     # 0x2d03d
movl $0x1, %edx
movq %rax, %rdi
jmp 0x9bb2
leaq 0x23a5f(%rip), %rsi     # 0x2d609
movl $0xc, %edx
movq %rbx, %rdi
callq 0x6370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6200
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsi,%rax)
movl 0x8(%rdi), %esi
movq %r14, %rdi
callq 0x6540
leaq 0x23a9c(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
movq %rbx, (%rsp)
testl %ebx, %ebx
jle 0x9c51
leaq 0x25b1a(%rip), %r12     # 0x2f751
movq (%rsp), %rax
movl %eax, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6370
decl %ebp
jne 0x9c3d
leaq 0x23a42(%rip), %rsi     # 0x2d69a
movl $0x5, %edx
movq %r14, %rdi
callq 0x6370
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq 0x78(%r15), %r13
cmpq 0x80(%r15), %r13
je 0x9d23
movq (%rsp), %rax
leal 0x1(%rax), %ebx
leaq 0x25aa6(%rip), %r12     # 0x2f751
cmpq 0x78(%r15), %r13
je 0x9d08
cmpl $0x0, (%rsp)
js 0x9ccd
movl %ebx, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6370
decl %ebp
jne 0x9cb9
movl $0x6, %edx
movq %r14, %rdi
leaq 0x239b1(%rip), %rsi     # 0x2d68d
callq 0x6370
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq (%r13), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *(%rax)
addq $0x8, %r13
cmpq 0x80(%r15), %r13
jne 0x9cab
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsi,%rax)
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x6540
leaq 0x23952(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
testl %r15d, %r15d
jle 0x9d95
leaq 0x259d3(%rip), %r12     # 0x2f751
movl %r15d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6370
decl %ebp
jne 0x9d81
leaq 0x23904(%rip), %rsi     # 0x2d6a0
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq 0x78(%r14), %rdi
leal 0x1(%r15), %edx
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rbx,%rax)
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x6540
leaq 0x238b4(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
testl %r15d, %r15d
jle 0x9e31
leaq 0x25935(%rip), %r12     # 0x2f751
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6370
decl %r15d
jne 0x9e1c
leaq 0x2386d(%rip), %rsi     # 0x2d6a5
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6370
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
movq %rbx, %rdi
callq 0x6370
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsi,%rax)
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x6540
leaq 0x237f6(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
testl %r15d, %r15d
jle 0x9ef1
leaq 0x25877(%rip), %r12     # 0x2f751
movl %r15d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6370
decl %ebp
jne 0x9edd
leaq 0x237b3(%rip), %rsi     # 0x2d6ab
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6370
movq 0x88(%r14), %rsi
movq 0x90(%r14), %rdx
movq %rbx, %rdi
callq 0x6370
movq %rax, %r12
leaq 0x235d3(%rip), %rsi     # 0x2d4f8
movl $0x1, %edx
movq %rax, %rdi
callq 0x6370
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rbx,%rax)
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x6540
leaq 0x2373a(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
testl %r15d, %r15d
jle 0x9fad
leaq 0x257bb(%rip), %r12     # 0x2f751
movl %r15d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6370
decl %ebp
jne 0x9f99
leaq 0x236fd(%rip), %rsi     # 0x2d6b1
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6370
movq 0x78(%r14), %rdi
leal 0x1(%r15), %ebp
movq (%rdi), %rax
movq %rbx, %rsi
movl %ebp, %edx
callq *(%rax)
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rbx,%rax)
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x6540
leaq 0x236c1(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
testl %r15d, %r15d
jle 0xa024
leaq 0x25742(%rip), %r12     # 0x2f751
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6370
decl %r15d
jne 0xa00f
leaq 0x2368f(%rip), %rsi     # 0x2d6ba
movl $0xd, %edx
movq %rbx, %rdi
callq 0x6370
movq 0x80(%r14), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_un_op::fill_and_check(symbol_table*)
void AST_un_op::fill_and_check(symbol_table* st){
    expr->fill_and_check(st);
    
    if ( expr->type == BOOLEAN ){
        if ( oper_type == NOT ){
            type = BOOLEAN;
        } else {
            // Reportar error de argumento booleano y operando menos unario
            logger->buf << "Operando de tipo boolean, esperado float o int.";
            logger->error(line, column);
        }
    } else if ( expr->type == INT || expr->type == FLOAT ){
        
        if ( oper_type == NEG ){
            type = expr->type;
        } else {
            // Reportar error de argumento numero y operando negacion
            logger->buf << "Operando de tipo '" << (expr->type == INT ? "int": "float")
                        << "', esperado boolean.";
            logger->error(line, column);
        }
    } else {
        // Reportar error de tipo de argumento
        logger->buf << "Operando de tipo '" << types.types[expr->type]->name
                    << "', esperado '" << (oper_type == NOT ? "boolean": "float o int")
                    << "'.";
        logger->error(line, column);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rax
movl 0x10(%rax), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0xa7a3
cmpl $0x0, 0x48(%rbx)
je 0xa86f
leaq 0x34cc0(%rip), %r15     # 0x3f408
movq (%r15), %r14
addq $0x48, %r14
leaq 0x230e6(%rip), %rsi     # 0x2d83c
movl $0x12, %edx
movq %r14, %rdi
callq 0x6370
movq 0x50(%rbx), %rax
xorl %ecx, %ecx
cmpl $0x3, 0x10(%rax)
setne %cl
leaq 0x23111(%rip), %rax     # 0x2d888
leaq 0x230d1(%rip), %rsi     # 0x2d84f
cmoveq %rax, %rsi
leaq 0x3(,%rcx,2), %rdx
movq %r14, %rdi
callq 0x6370
leaq 0x230bc(%rip), %rsi     # 0x2d855
movl $0x14, %edx
jmp 0xa854
cmpl $0x6, %eax
jne 0xa7be
cmpl $0x1, 0x48(%rbx)
jne 0xa878
movl $0x6, 0x10(%rbx)
jmp 0xa872
leaq 0x34c43(%rip), %r15     # 0x3f408
movq (%r15), %r14
addq $0x48, %r14
leaq 0x23069(%rip), %rsi     # 0x2d83c
movl $0x12, %edx
movq %r14, %rdi
callq 0x6370
movq 0x50(%rbx), %rax
movslq 0x10(%rax), %rax
leaq 0x34c21(%rip), %rcx     # 0x3f410
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6370
movq %rax, %r14
leaq 0x2305a(%rip), %rsi     # 0x2d86a
movl $0xd, %edx
movq %rax, %rdi
callq 0x6370
xorl %eax, %eax
cmpl $0x1, 0x48(%rbx)
setne %al
leaq 0x2304b(%rip), %rcx     # 0x2d878
leaq 0x2304c(%rip), %rsi     # 0x2d880
cmoveq %rcx, %rsi
leaq 0x7(,%rax,4), %rdx
movq %r14, %rdi
callq 0x6370
leaq 0x27d48(%rip), %rsi     # 0x32597
movl $0x2, %edx
movq %r14, %rdi
callq 0x6370
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1aa40
movl %eax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x34b89(%rip), %r14     # 0x3f408
movq (%r14), %rdi
addq $0x48, %rdi
leaq 0x22f7f(%rip), %rsi     # 0x2d80c
movl $0x2f, %edx
callq 0x6370
movq (%r14), %rdi
jmp 0xa85f
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x48(%rbx), %rax
movslq 0x10(%rax), %rax
leaq 0x34490(%rip), %rcx     # 0x3f410
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xafc9
movq (%r14), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x2424f(%rip), %rax     # 0x2f1ed
cmpq %rax, %rdi
je 0xafbd
movl $0x1, %ebp
cmpb $0x2a, (%rdi)
je 0xafc1
leaq 0x24239(%rip), %rsi     # 0x2f1ed
callq 0x6410
testl %eax, %eax
jne 0xafc1
movl 0x30(%r14), %ebp
movl %ebp, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x6350
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_address::fill_and_check(symbol_table*, bool)
void AST_address::fill_and_check(symbol_table* st, bool lval){

    value->fill_and_check(st, true);

    if (typeid(value) == typeid(AST_address)) {
        type = INVALID;
    } else {

        pointer_descriptor* pd = new pointer_descriptor( value->type,
                                                         types.types[
                                                             value->type]->name);

        if ( !types.has_type( pd->name ) ){
            type = types.add_type( pd );
        } else {
            type = types.index_of( pd->name );
            delete pd;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x10(%rax)
movl $0x38, %edi
callq 0x62f0
movq %rax, %r14
movq %rax, %rbx
movq 0x48(%r15), %rax
movslq 0x10(%rax), %r12
leaq 0x34403(%rip), %rax     # 0x3f410
movq (%rax), %rax
movq (%rax,%r12,8), %rax
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x16c68
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x19210
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xb059
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x16c68
leaq 0x3438f(%rip), %rdi     # 0x3f410
movq %r12, %rsi
callq 0x1a04e
movl %eax, %ebp
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0xb0a2
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6300
testb %bpl, %bpl
je 0xb12b
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x16c68
leaq 0x3433d(%rip), %rdi     # 0x3f410
movq %r12, %rsi
callq 0x1a0f6
movl %eax, 0x10(%r15)
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xb0f6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
leaq 0x33a93(%rip), %rax     # 0x3eb90
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %r14
cmpq %r14, %rdi
je 0xb11c
movq (%r14), %rsi
incq %rsi
callq 0x6300
movl $0x38, %esi
movq %rbx, %rdi
callq 0x6300
jmp 0xb13e
leaq 0x342de(%rip), %rdi     # 0x3f410
movq %rbx, %rsi
callq 0x19fb8
movl %eax, 0x10(%r15)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xb1a4
movq 0x38(%rsp), %rsi
jmp 0xb173
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0xb1a4
movq 0x58(%rsp), %rsi
incq %rsi
jmp 0xb19f
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xb197
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0xb197
movq %rax, %r14
movl $0x38, %esi
movq %rbx, %rdi
callq 0x6300
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0xb28f
movq (%rdi), %rax
movzbl %dl, %edx
callq *0x10(%rax)
movq 0x48(%rbx), %rax
movslq 0x10(%rax), %rax
leaq 0x34234(%rip), %r15     # 0x3f410
movq (%r15), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xb29b
movq (%r14), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x23fdc(%rip), %rax     # 0x2f1da
cmpq %rax, %rdi
je 0xb288
cmpb $0x2a, (%rdi)
je 0xb21c
leaq 0x23fc7(%rip), %rsi     # 0x2f1da
callq 0x6410
testl %eax, %eax
je 0xb288
leaq 0x341e5(%rip), %r12     # 0x3f408
movq (%r12), %r14
addq $0x48, %r14
leaq 0x2270f(%rip), %rsi     # 0x2d941
movl $0x23, %edx
movq %r14, %rdi
callq 0x6370
movq 0x48(%rbx), %rax
movslq 0x10(%rax), %rax
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6370
leaq 0x27332(%rip), %rsi     # 0x32597
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
movq (%r12), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1aa40
movl $0x1, %eax
jmp 0xb28c
movl 0x3c(%r14), %eax
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x6350
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rax
movl 0x10(%rax), %esi
movl %esi, 0x48(%rbx)
leaq 0x33df4(%rip), %r14     # 0x3f410
movq %r14, %rdi
callq 0x1a0ec
testb %al, %al
je 0xb64b
movl 0x10(%rbx), %esi
leaq 0x33dde(%rip), %rdi     # 0x3f410
callq 0x1a0ec
testb %al, %al
je 0xb64b
cmpl $0x7, 0x48(%rbx)
je 0xb64b
cmpl $0x7, 0x10(%rbx)
jne 0xb6e5
leaq 0x33db6(%rip), %r12     # 0x3f408
movq (%r12), %r15
addq $0x48, %r15
leaq 0x22342(%rip), %rsi     # 0x2d9a3
movl $0x35, %edx
movq %r15, %rdi
callq 0x6370
movslq 0x48(%rbx), %rax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r15, %rdi
callq 0x6370
movq %rax, %r15
leaq 0x22346(%rip), %rsi     # 0x2d9d9
movl $0x5, %edx
movq %rax, %rdi
callq 0x6370
movslq 0x10(%rbx), %rax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r15, %rdi
callq 0x6370
leaq 0x26ed5(%rip), %rsi     # 0x32597
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
movq (%r12), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1aa40
movl $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, %rdi
callq 0x185dc
movq %rax, %rbx
movq 0x98(%r14), %rdi
callq 0x1801a
movl %eax, 0x32e50(%rip)     # 0x3f314
movq 0xa0(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0xa8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movl $0x0, 0x32e26(%rip)     # 0x3f314
testq %rbx, %rbx
je 0xc4fb
movq %rbx, %rdi
callq 0x166f8
movl $0x48, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x10(%rax)
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0xcaac
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0x80(%rbx), %rcx
testq %rcx, %rcx
je 0xcaac
movq 0x78(%rbx), %rax
movl 0x10(%rax), %eax
testl %eax, %eax
je 0xcaac
movl 0x10(%rcx), %ecx
testl %ecx, %ecx
je 0xcaac
cmpl $0x1, %eax
je 0xcaac
cmpl $0x1, %ecx
je 0xcaac
cmpl %eax, %ecx
je 0xcaac
leaq 0x32a05(%rip), %r15     # 0x3f408
movq (%r15), %r14
addq $0x48, %r14
leaq 0x21217(%rip), %rsi     # 0x2dc28
movl $0x20, %edx
movq %r14, %rdi
callq 0x6370
movq 0x80(%rbx), %rax
movslq 0x10(%rax), %rax
leaq 0x329e0(%rip), %r12     # 0x3f410
movq (%r12), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6370
movq %rax, %r14
leaq 0x211f7(%rip), %rsi     # 0x2dc49
movl $0x16, %edx
movq %rax, %rdi
callq 0x6370
movq 0x78(%rbx), %rax
movslq 0x10(%rax), %rax
movq (%r12), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6370
leaq 0x25b11(%rip), %rsi     # 0x32597
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1aa40
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_return::fill_and_check(symbol_table*)
void AST_return::fill_and_check(symbol_table* st){
    
    if ( expected_return == NONE && expr ){
        logger->buf << "No se esperaba retorno con valor.";
        logger->error(line, column);
    } else if ( expected_return != NONE && !expr ){
        logger->buf << "Se esperaba retorno de tipo '"
                    << types.types[expected_return]->name << "'.";
        logger->error(line, column);
    } else if ( expected_return != NONE && expr ){
        expr->fill_and_check(st);
        if ( expr->type != expected_return ){
            logger->buf << "Se esperaba retorno de tipo '"
                        << types.types[expected_return]->name << "', '"
                        << types.types[expr->type]->name << "' obtenido.";
            logger->error(line, column);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x32834(%rip), %eax     # 0x3f314
cmpl $0x2, %eax
setne %cl
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
sete %dl
orb %cl, %dl
je 0xcb63
testq %rdi, %rdi
sete %cl
cmpl $0x2, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xcb9c
leaq 0x328f6(%rip), %rax     # 0x3f408
movq (%rax), %r14
addq $0x48, %r14
leaq 0x21162(%rip), %rsi     # 0x2dc82
movl $0x1d, %edx
movq %r14, %rdi
callq 0x6370
movslq 0x327e0(%rip), %rax     # 0x3f314
leaq 0x328d5(%rip), %rcx     # 0x3f410
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6370
leaq 0x25a3e(%rip), %rsi     # 0x32597
movl $0x2, %edx
movq %rax, %rdi
jmp 0xcb7d
leaq 0x3289e(%rip), %rax     # 0x3f408
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x210e8(%rip), %rsi     # 0x2dc60
movl $0x21, %edx
callq 0x6370
leaq 0x3287f(%rip), %rax     # 0x3f408
movq (%rax), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1aa40
testq %rdi, %rdi
sete %cl
cmpl $0x2, %eax
sete %al
orb %cl, %al
jne 0xcbc1
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x78(%rbx), %rax
movl 0x10(%rax), %eax
cmpl 0x32755(%rip), %eax     # 0x3f314
jne 0xcbc7
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3283a(%rip), %rax     # 0x3f408
movq (%rax), %r14
addq $0x48, %r14
leaq 0x210a6(%rip), %rsi     # 0x2dc82
movl $0x1d, %edx
movq %r14, %rdi
callq 0x6370
movslq 0x32724(%rip), %rax     # 0x3f314
leaq 0x32819(%rip), %r15     # 0x3f410
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6370
movq %rax, %r14
leaq 0x21088(%rip), %rsi     # 0x2dca0
movl $0x4, %edx
movq %rax, %rdi
callq 0x6370
movq 0x78(%rbx), %rax
movslq 0x10(%rax), %rax
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6370
leaq 0x2105a(%rip), %rsi     # 0x2dca5
movl $0xb, %edx
jmp 0xcb5e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0xccae
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x78(%r14), %rax
cmpl $0x6, 0x10(%rax)
je 0xccae
leaq 0x32784(%rip), %r15     # 0x3f408
movq (%r15), %rdi
addq $0x48, %rdi
leaq 0x2101f(%rip), %rsi     # 0x2dcb1
movl $0x14, %edx
callq 0x6370
movq (%r15), %rdi
movq 0x78(%r14), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x1aa40
movq %rbx, %rdi
callq 0x185dc
movq %rax, %r15
movq 0x80(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x8(%rax)
testq %r15, %r15
je 0xccd6
movq %r15, %rdi
callq 0x166f8
movl $0x48, %esi
movq %r15, %rdi
callq 0x6300
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0xcd00
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0xcd61
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0x78(%rbx), %rax
movl 0x10(%rax), %eax
cmpl $0x1, %eax
je 0xcd61
cmpl $0x6, %eax
je 0xcd61
leaq 0x326cd(%rip), %r15     # 0x3f408
movq (%r15), %rdi
addq $0x48, %rdi
leaq 0x20f68(%rip), %rsi     # 0x2dcb1
movl $0x14, %edx
callq 0x6370
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1aa40
movq %r14, %rdi
callq 0x185dc
movq %rax, %r14
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
testq %r14, %r14
je 0xcd89
movq %r14, %rdi
callq 0x166f8
movl $0x48, %esi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6300
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_bounded_loop::fill_and_check(symbol_table*)
void AST_bounded_loop::fill_and_check(symbol_table* st){

    if (0 != left_bound) {
        left_bound->fill_and_check(st);
    }
    if (0 != right_bound) {
        right_bound->fill_and_check(st);
    }
    
    if ( 0 == left_bound || left_bound->type == INVALID
        || 0 == right_bound || right_bound->type == INVALID )
    {
        return;
    } else if ( left_bound->type != right_bound->type ){
        logger->buf << "Ambos límites deben tener el mismo tipo.";
        logger->error(line, column);
    } else if ( left_bound->type != INT
                && left_bound->type != CHAR
                && left_bound->type != BOOLEAN
              )
    {
        logger->buf << "Se esperaba un tipo discreto int, char, boolean.";
        logger->error(line, column);
    }
    
    symbol_table* nested_block = st->new_son();
    
    sym = new symbol(name, true, left_bound->type, line_name, column_name,true);
    nested_block->insert(sym);
    
    blck->fill_and_check(nested_block);
    delete nested_block;
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
testq %rdi, %rdi
je 0xcdc2
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0xcdd7
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0xcf32
movl 0x10(%rax), %eax
cmpl $0x1, %eax
je 0xcf32
movq 0xb0(%rbx), %rcx
testq %rcx, %rcx
je 0xcf32
movl 0x10(%rcx), %ecx
cmpl $0x1, %ecx
je 0xcf32
cmpl %ecx, %eax
jne 0xce3e
cmpl $0x6, %eax
ja 0xce22
movl $0x68, %ecx
btl %eax, %ecx
jb 0xce72
leaq 0x325df(%rip), %rax     # 0x3f408
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x20eb9(%rip), %rsi     # 0x2dcf0
movl $0x30, %edx
jmp 0xce58
leaq 0x325c3(%rip), %rax     # 0x3f408
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x20e73(%rip), %rsi     # 0x2dcc6
movl $0x29, %edx
callq 0x6370
leaq 0x325a4(%rip), %rax     # 0x3f408
movq (%rax), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1aa40
movq %r14, %rdi
callq 0x185dc
movq %rax, %r14
movl $0x78, %edi
callq 0x62f0
movq %rax, %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x16c68
movq 0xa8(%rbx), %rax
movl 0x10(%rax), %ecx
movl 0xa0(%rbx), %r8d
movl 0xa4(%rbx), %r9d
movl $0x1, (%rsp)
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x17f4a
movq %r15, 0x98(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xcf02
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq 0x98(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x184e6
movq 0xb8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x166f8
movl $0x48, %esi
movq %r14, %rdi
callq 0x6300
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xcf5d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0xcf5d
movq %rax, %rbx
movl $0x78, %esi
movq %r15, %rdi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_read::fill_and_check(symbol_table*)
void AST_read::fill_and_check(symbol_table* st){
    sym = st->lookup(variable);
    
    /* El simbolo existe en la tabla */
    if ( sym ){
        
        /* El simbolo es una function, uso incorrecto como variable */
        if ( sym->is_function ){
            logger->buf << "Identificador '" << sym->getName()
                        << "' definido como función en "
                        << sym->getLine() << ':' << sym->getColumn() << '.';
            logger->error(line, column);
            sym = 0;
        }
    } else {
        /* El simbolo no existe en la tabla */
        logger->buf << "Identificador '" << variable << "' no definido previamente.";
        logger->error(line, column);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x78(%rdi), %rsi
movq 0x80(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x16c68
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x183ea
movq %rax, 0x98(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xcfde
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq 0x98(%rbx), %rax
testq %rax, %rax
je 0xd0de
cmpb $0x1, 0x31(%rax)
jne 0xd135
leaq 0x32410(%rip), %r12     # 0x3f408
movq (%r12), %r14
addq $0x48, %r14
leaq 0x20885(%rip), %rsi     # 0x2d88c
movl $0xf, %edx
movq %r14, %rdi
callq 0x6370
movq 0x98(%rbx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x17ff4
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x6370
movq %rax, %r14
leaq 0x2085b(%rip), %rsi     # 0x2d89c
movl $0x1c, %edx
movq %rax, %rdi
callq 0x6370
movq 0x98(%rbx), %rdi
callq 0x1801e
movq %r14, %rdi
movl %eax, %esi
callq 0x6540
leaq 0x7(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x6370
movq %rax, %r14
movq 0x98(%rbx), %rdi
callq 0x18022
movq %r14, %rdi
movl %eax, %esi
callq 0x6540
leaq 0x7(%rsp), %rsi
movb $0x2e, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x6370
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd0c2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
movq (%r12), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1aa40
movq $0x0, 0x98(%rbx)
jmp 0xd135
leaq 0x32323(%rip), %r15     # 0x3f408
movq (%r15), %r14
addq $0x48, %r14
leaq 0x20799(%rip), %rsi     # 0x2d88c
movl $0xf, %edx
movq %r14, %rdi
callq 0x6370
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rdx
movq %r14, %rdi
callq 0x6370
leaq 0x207e7(%rip), %rsi     # 0x2d901
movl $0x1a, %edx
movq %rax, %rdi
callq 0x6370
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1aa40
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xd173
movq 0x18(%rsp), %rsi
jmp 0xd16b
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd173
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, 0x48(%rbx)
jne 0x10179
movq 0x50(%rbx), %rdx
leaq 0x18(%rdx), %rax
leaq 0x30(%rbx), %rdi
cmpq %rax, %rdi
je 0x1015d
movq (%rax), %rsi
movq %rax, %rdx
callq 0x16cfe
movq 0x50(%rbx), %rdx
addq $0x30, %rdx
addq $0x18, %rbx
cmpq %rdx, %rbx
je 0x10175
movq (%rdx), %rsi
movq %rbx, %rdi
callq 0x16cfe
xorl %ebx, %ebx
jmp 0x101e2
movq %rax, %r15
movl $0x18, %edi
callq 0x62f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1d014
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1e2e8(%rip), %rsi     # 0x2e489
leaq 0x1e2fe(%rip), %rdx     # 0x2e4a6
movq %rsp, %r12
movq %r12, %rdi
callq 0x7008
movq %r14, %rdi
movl $0x15, %esi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x2b238
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x101e2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x10219
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0x10214
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x6300
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x30(%rdi), %r14
leaq 0x18(%rdi), %rax
leaq 0x40(%rdi), %rcx
leaq 0x28(%rdi), %r15
cmpb $0x0, 0x48(%rdi)
cmovneq %rax, %r14
cmoveq %rcx, %r15
movq %r14, %rdi
callq 0x16888
movq %rbx, %rdi
callq 0x2b316
movl %eax, %ebp
movl $0x18, %edi
callq 0x62f0
movl %ebp, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x6080
incq (%r15)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1de20(%rip), %rsi     # 0x2e4d4
leaq 0x1de36(%rip), %rdx     # 0x2e4f1
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7008
movq %rbx, %rdi
movl $0x16, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2b238
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x106f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1071d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
cmpl $0x0, (%rdx)
je 0x10801
movq %rdx, %r13
movq %rdi, %r15
movl $0x18, %edi
callq 0x62f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1d014
movl $0x18, %edi
callq 0x62f0
movq %rax, %r12
movl (%r13), %esi
movq %rax, %rdi
movl $0x2, %edx
callq 0x1d02a
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x1dd79(%rip), %rsi     # 0x2e534
leaq 0x1ddba(%rip), %rdx     # 0x2e57c
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x7008
movq %r15, %rdi
movl $0x11, %esi
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x2b238
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x10804
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x10804
movq %r14, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1084a
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x10845
movq %rax, %r14
movl $0x18, %esi
movq %r12, %rdi
jmp 0x10845
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x6300
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r12
movl $0x18, %edi
callq 0x62f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1d014
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x10758
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1dc43(%rip), %rsi     # 0x2e57d
leaq 0x1dc53(%rip), %rdx     # 0x2e594
movq %rsp, %r12
movq %r12, %rdi
callq 0x7008
movq %r14, %rdi
movl $0x4, %esi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x2b238
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1097b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x109b2
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0x109ad
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x6300
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_address::gen_tac_lval(Tac*, int*)
opd *AST_address::gen_tac_lval(Tac* t, int *sta_base){
    opd *o = value->gen_tac_lval(t, sta_base), *r = new opd();
    o = gen_tac_lval_disp(t, o, sta_base);
    t->append_quad(inst::REF, r, o, 0, "referenciar un lvalue");
    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r12
movl $0x18, %edi
callq 0x62f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1d014
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x10758
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1db6f(%rip), %rsi     # 0x2e57f
leaq 0x1db7d(%rip), %rdx     # 0x2e594
movq %rsp, %r12
movq %r12, %rdi
callq 0x7008
movq %r14, %rdi
movl $0x3, %esi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x2b238
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x10a51
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x10a88
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0x10a83
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x6300
movq %r14, %rdi
callq 0x6560