LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_address::dump(std::ostream&, int)
void AST_address::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << "Pointer to:" << endl;
    value->dump(strm, indentation+1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
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 0x6530
leaq 0x2488b(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebx, %ebx
jle 0x7e5a
leaq 0x2690d(%rip), %r12     # 0x2e751
movl %ebx, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x7e46
leaq 0x246d0(%rip), %rsi     # 0x2c531
movl $0xb, %edx
movq %r14, %rdi
callq 0x6360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x48(%r15), %rdi
incl %ebx
movq (%rdi), %rax
movq (%rax), %rax
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_array_access::dump(std::ostream&, int)
void AST_array_access::dump(ostream &strm, int indentation){
    
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    if (index == 0){
        strm << "Error in array access" << endl;
        return;
    }
    
    strm << "Get: [" << types.types[type]->name << "]" << endl;
    
    // si hay un error, no habr�a �ndice
    if (0 != index) {
        index->dump(strm, indentation+1);
    }
    
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << "From:" << endl;
    
    value->dump(strm, indentation+1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsi,%rax)
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x6530
leaq 0x247d4(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %r14d, %r14d
jle 0x7f13
leaq 0x26855(%rip), %r12     # 0x2e751
movl %r14d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x7eff
cmpq $0x0, 0x50(%r15)
je 0x8053
leaq 0x2462e(%rip), %rsi     # 0x2c553
movl $0x6, %edx
movq %rbx, %rdi
callq 0x6360
movslq 0x10(%r15), %rax
leaq 0x364cb(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x6360
movq %rax, %r12
leaq 0x240df(%rip), %rsi     # 0x2c03d
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x50(%r15), %rdi
testq %rdi, %rdi
je 0x7fa8
leal 0x1(%r14), %edx
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rbx,%rax)
movl 0x8(%r15), %esi
movq %rbx, %rdi
callq 0x6530
leaq 0x246ec(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %r14d, %r14d
jle 0x7ffb
leaq 0x2676d(%rip), %r12     # 0x2e751
movl %r14d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x7fe7
leaq 0x24558(%rip), %rsi     # 0x2c55a
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x48(%r15), %rdi
incl %r14d
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
movl %r14d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0x244e3(%rip), %rsi     # 0x2c53d
movl $0x15, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61f0
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_struct_access::dump(std::ostream&, int)
void AST_struct_access::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << "Get " << field << "[" << types.types[type]->name << "] ";
    strm << "from:" << endl;
    
    value->dump(strm, indentation+1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
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 0x6530
leaq 0x245ef(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebx, %ebx
jle 0x80f6
leaq 0x26671(%rip), %r12     # 0x2e751
movl %ebx, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x80e2
leaq 0x24463(%rip), %rsi     # 0x2c560
movl $0x4, %edx
movq %r14, %rdi
callq 0x6360
movq 0x50(%r15), %rsi
movq 0x58(%r15), %rdx
movq %r14, %rdi
callq 0x6360
movq %rax, %r12
leaq 0x24434(%rip), %rsi     # 0x2c558
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
movslq 0x10(%r15), %rax
leaq 0x362cc(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r12, %rdi
callq 0x6360
leaq 0x24352(%rip), %rsi     # 0x2c4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
leaq 0x243f7(%rip), %rsi     # 0x2c565
movl $0x5, %edx
movq %r14, %rdi
callq 0x6360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x48(%r15), %rdi
incl %ebx
movq (%rdi), %rax
movq (%rax), %rax
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_op::binary_operator[abi:cxx11]()
string AST_op::binary_operator(){
    switch ( oper_type ){
        case PLUS:
            return "+";
        case MINUS:
            return "-";
        case PROD:
            return "*";
        case DIV:
            return "/";
        case MOD:
            return "%";
        case AND:
            return "&&";
        case OR:
            return "||";
        case IMP:
            return "==>";
        case CONSEQ:
            return "<==";
        case EQ:
            return "==";
        case UNEQ:
            return "!=";
        case LESS:
            return "<";
        case LESS_EQ:
            return "<=";
        case GREAT:
            return ">";
        case GREAT_EQ:
            return ">=";
    }
    return "";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x68(%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
cmpq $0xe, %rax
ja 0x826b
leaq 0x23eaf(%rip), %rcx     # 0x2c08c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2437e(%rip), %rsi     # 0x2c56b
leaq 0x24378(%rip), %rdx     # 0x2c56c
jmp 0x82fb
leaq 0x24387(%rip), %rsi     # 0x2c587
leaq 0x24382(%rip), %rdx     # 0x2c589
jmp 0x82fb
leaq 0x2436f(%rip), %rsi     # 0x2c582
leaq 0x24369(%rip), %rdx     # 0x2c583
jmp 0x82fb
leaq 0x24349(%rip), %rsi     # 0x2c56f
leaq 0x24343(%rip), %rdx     # 0x2c570
jmp 0x82fb
leaq 0x2434b(%rip), %rsi     # 0x2c584
leaq 0x24346(%rip), %rdx     # 0x2c586
jmp 0x82fb
leaq 0x24330(%rip), %rsi     # 0x2c57c
leaq 0x2432b(%rip), %rdx     # 0x2c57e
jmp 0x82fb
leaq 0x26483(%rip), %rsi     # 0x2e6e2
leaq 0x2647d(%rip), %rdx     # 0x2e6e3
jmp 0x82fb
leaq 0x26110(%rip), %rdx     # 0x2e382
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x82fe
leaq 0x242e9(%rip), %rsi     # 0x2c56d
leaq 0x242e3(%rip), %rdx     # 0x2c56e
jmp 0x82fb
leaq 0x242e3(%rip), %rsi     # 0x2c577
leaq 0x242df(%rip), %rdx     # 0x2c57a
jmp 0x82fb
leaq 0x26475(%rip), %rsi     # 0x2e719
leaq 0x2646f(%rip), %rdx     # 0x2e71a
jmp 0x82fb
leaq 0x242bd(%rip), %rsi     # 0x2c571
leaq 0x242b8(%rip), %rdx     # 0x2c573
jmp 0x82fb
leaq 0x2609f(%rip), %rsi     # 0x2e363
leaq 0x26099(%rip), %rdx     # 0x2e364
jmp 0x82fb
leaq 0x242a0(%rip), %rsi     # 0x2c574
leaq 0x2429b(%rip), %rdx     # 0x2c576
jmp 0x82fb
leaq 0x2429b(%rip), %rsi     # 0x2c57f
leaq 0x24296(%rip), %rdx     # 0x2c581
jmp 0x82fb
leaq 0x24287(%rip), %rsi     # 0x2c57b
leaq 0x24283(%rip), %rdx     # 0x2c57e
movq %rbx, %rdi
callq 0x6fec
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_op::dump(std::ostream&, int)
void AST_op::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << binary_operator() << " [" << types.types[type]->name << "]" << endl;
    
    left->dump(strm, indentation+1);
    right->dump(strm, indentation+1);
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
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 0x6530
leaq 0x24379(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebx, %ebx
jle 0x836c
leaq 0x263fb(%rip), %r12     # 0x2e751
movl %ebx, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x8358
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x81be
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x6360
movq %rax, %r12
leaq 0x241c2(%rip), %rsi     # 0x2c557
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
movslq 0x10(%r15), %rax
leaq 0x3605b(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r12, %rdi
callq 0x6360
movq %rax, %r12
leaq 0x23c6f(%rip), %rsi     # 0x2c03d
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x841e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
movq 0x58(%r15), %rdi
incl %ebx
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *(%rax)
movq 0x60(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8467
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_un_op::unary_operator[abi:cxx11]()
string AST_un_op::unary_operator(){
    
    switch ( oper_type ){
        case NOT:
            return "!";
        case NEG:
            return "-";
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
cmpl $0x1, 0x48(%rsi)
movq %rax, (%rdi)
jne 0x8491
leaq 0x296a6(%rip), %rsi     # 0x31b2e
leaq 0x296a0(%rip), %rdx     # 0x31b2f
jmp 0x849f
leaq 0x26281(%rip), %rsi     # 0x2e719
leaq 0x2627b(%rip), %rdx     # 0x2e71a
movq %rbx, %rdi
callq 0x6fec
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_un_op::dump(std::ostream&, int)
void AST_un_op::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << "Unary " << unary_operator()
         << " [" << types.types[type]->name << "]" << endl;
    
    expr->dump(strm, indentation+1);
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
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 0x6530
leaq 0x241d5(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebx, %ebx
jle 0x8510
leaq 0x26257(%rip), %r12     # 0x2e751
movl %ebx, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x84fc
leaq 0x24073(%rip), %rsi     # 0x2c58a
movl $0x6, %edx
movq %r14, %rdi
callq 0x6360
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8470
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x6360
movq %rax, %r12
leaq 0x2400a(%rip), %rsi     # 0x2c557
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
movslq 0x10(%r15), %rax
leaq 0x35ea3(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r12, %rdi
callq 0x6360
movq %rax, %r12
leaq 0x23ab7(%rip), %rsi     # 0x2c03d
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x85d6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
movq 0x50(%r15), %rdi
incl %ebx
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8611
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_ident::dump(std::ostream&, int)
void AST_ident::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << "Identifier: " << value;
    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 0x6530
leaq 0x23c1b(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebp, %ebp
jle 0x8ac8
leaq 0x25c9d(%rip), %r15     # 0x2e751
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6360
decl %ebp
jne 0x8ab4
leaq 0x23b2d(%rip), %rsi     # 0x2c5fc
movl $0xc, %edx
movq %rbx, %rdi
callq 0x6360
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
movq %rbx, %rdi
callq 0x6360
cmpq $0x0, 0x68(%r14)
je 0x8b98
leaq 0x23a59(%rip), %rsi     # 0x2c557
movl $0x2, %edx
movq %rbx, %rdi
callq 0x6360
movq 0x68(%r14), %rdi
callq 0x17fde
cltq
leaq 0x358eb(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x6360
movq %rax, %r15
leaq 0x257cc(%rip), %r12     # 0x2e30a
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x6360
movq 0x68(%r14), %rdi
callq 0x17fe2
movq %r15, %rdi
movl %eax, %esi
callq 0x6530
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x6360
movq 0x68(%r14), %rdi
callq 0x17fe6
movq %r15, %rdi
movl %eax, %esi
callq 0x6530
leaq 0x234af(%rip), %rsi     # 0x2c03d
movl $0x1, %edx
movq %rax, %rdi
jmp 0x8ba7
leaq 0x23a6a(%rip), %rsi     # 0x2c609
movl $0xc, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_conversion::dump(std::ostream&, int)
void AST_conversion::dump(ostream &strm, int indentation){
    
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    
    strm << "Conversion from " << types.types[original_type]->name
         << " to " << types.types[type]->name << endl;
     
     expr->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 0x6530
leaq 0x2375e(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebx, %ebx
jle 0x8f87
leaq 0x257e0(%rip), %r12     # 0x2e751
movl %ebx, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x8f73
leaq 0x23688(%rip), %rsi     # 0x2c616
movl $0x10, %edx
movq %r14, %rdi
callq 0x6360
movslq 0x48(%r15), %rax
leaq 0x35462(%rip), %r13     # 0x3e408
movq (%r13), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6360
movq %rax, %r12
leaq 0x2365f(%rip), %rsi     # 0x2c627
movl $0x4, %edx
movq %rax, %rdi
callq 0x6360
movslq 0x10(%r15), %rax
movq (%r13), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r12, %rdi
callq 0x6360
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x50(%r15), %rdi
incl %ebx
movq (%rdi), %rax
movq (%rax), %rax
movq %r14, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/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:
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 0x6530
leaq 0x2332f(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebp, %ebp
jle 0x93b8
leaq 0x253b1(%rip), %r15     # 0x2e751
movl %ebp, %r12d
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6360
decl %r12d
jne 0x93a3
cmpq $0x0, 0x78(%r14)
je 0x9456
leaq 0x23291(%rip), %rsi     # 0x2c65b
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6360
movq 0x78(%r14), %rax
movslq 0x10(%rax), %rax
leaq 0x35022(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x6360
movq %rax, %r15
leaq 0x22c36(%rip), %rsi     # 0x2c03d
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x78(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0x23207(%rip), %rsi     # 0x2c664
movl $0xc, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6530
leaq 0x231e6(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebx, %ebx
jle 0x9501
leaq 0x25268(%rip), %r12     # 0x2e751
movl %ebx, %r13d
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %r13d
jne 0x94ec
testb %bpl, %bpl
je 0x9514
leaq 0x23169(%rip), %rsi     # 0x2c676
movl $0x2, %edx
jmp 0x9535
cmpq $0x0, 0x78(%r15)
je 0x9529
leaq 0x2314f(%rip), %rsi     # 0x2c671
movl $0x7, %edx
jmp 0x9535
leaq 0x23149(%rip), %rsi     # 0x2c679
movl $0x4, %edx
movq %r14, %rdi
callq 0x6360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
testl %ebx, %ebx
js 0x9586
leal 0x1(%rbx), %ebp
leaq 0x251df(%rip), %r12     # 0x2e751
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x9572
leal 0x1(%rbx), %ebp
leaq 0x22f5b(%rip), %rsi     # 0x2c4eb
movl $0x6, %edx
movq %r14, %rdi
callq 0x6360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x78(%r15), %rdi
testq %rdi, %rdi
je 0x95d7
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *(%rax)
testl %ebx, %ebx
js 0x95fa
leaq 0x2516f(%rip), %r12     # 0x2e751
movl %ebp, %r13d
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %r13d
jne 0x95e5
leaq 0x22ef2(%rip), %rsi     # 0x2c4f3
movl $0x6, %edx
movq %r14, %rdi
callq 0x6360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x80(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *(%rax)
movq 0x88(%r15), %rdi
testq %rdi, %rdi
je 0x9670
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_O1/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 0x6530
leaq 0x23004(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %r15d, %r15d
jle 0x96e3
leaq 0x25085(%rip), %r12     # 0x2e751
movl %r15d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x96cf
leaq 0x22f94(%rip), %rsi     # 0x2c67e
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
testl %r15d, %r15d
js 0x9742
leal 0x1(%r15), %ebp
leaq 0x25023(%rip), %r12     # 0x2e751
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x972e
leal 0x1(%r15), %ebp
leaq 0x22d9e(%rip), %rsi     # 0x2c4eb
movl $0x6, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0x9794
movq (%rdi), %rax
movq %rbx, %rsi
movl %ebp, %edx
callq *(%rax)
testl %r15d, %r15d
js 0x97b8
leaq 0x24fb1(%rip), %r15     # 0x2e751
movl %ebp, %r12d
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6360
decl %r12d
jne 0x97a3
leaq 0x22d34(%rip), %rsi     # 0x2c4f3
movl $0x6, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
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_O1/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 0x6530
leaq 0x22c4b(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebp, %ebp
jle 0x9a98
leaq 0x24ccd(%rip), %r15     # 0x2e751
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6360
decl %ebp
jne 0x9a84
leaq 0x22bf5(%rip), %rsi     # 0x2c694
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6360
movq 0x78(%r14), %rsi
movq 0x80(%r14), %rdx
movq %rbx, %rdi
callq 0x6360
cmpq $0x0, 0x98(%r14)
je 0x9b77
leaq 0x22a83(%rip), %rsi     # 0x2c557
movl $0x2, %edx
movq %rbx, %rdi
callq 0x6360
movq 0x98(%r14), %rdi
callq 0x17fde
cltq
leaq 0x34912(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x6360
movq %rax, %r15
leaq 0x247f3(%rip), %r12     # 0x2e30a
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x6360
movq 0x98(%r14), %rdi
callq 0x17fe2
movq %r15, %rdi
movl %eax, %esi
callq 0x6530
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x6360
movq 0x98(%r14), %rdi
callq 0x17fe6
movq %r15, %rdi
movl %eax, %esi
callq 0x6530
leaq 0x224d0(%rip), %rsi     # 0x2c03d
movl $0x1, %edx
movq %rax, %rdi
jmp 0x9b86
leaq 0x22a8b(%rip), %rsi     # 0x2c609
movl $0xc, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6530
leaq 0x22ac8(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
movq %rbx, (%rsp)
testl %ebx, %ebx
jle 0x9c25
leaq 0x24b46(%rip), %r12     # 0x2e751
movq (%rsp), %rax
movl %eax, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x9c11
leaq 0x22a6e(%rip), %rsi     # 0x2c69a
movl $0x5, %edx
movq %r14, %rdi
callq 0x6360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x78(%r15), %r13
cmpq 0x80(%r15), %r13
je 0x9cf7
movq (%rsp), %rax
leal 0x1(%rax), %ebx
leaq 0x24ad2(%rip), %r12     # 0x2e751
cmpq 0x78(%r15), %r13
je 0x9cdc
cmpl $0x0, (%rsp)
js 0x9ca1
movl %ebx, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x9c8d
movl $0x6, %edx
movq %r14, %rdi
leaq 0x229dd(%rip), %rsi     # 0x2c68d
callq 0x6360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq (%r13), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *(%rax)
addq $0x8, %r13
cmpq 0x80(%r15), %r13
jne 0x9c7f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6530
leaq 0x2297e(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %r15d, %r15d
jle 0x9d69
leaq 0x249ff(%rip), %r12     # 0x2e751
movl %r15d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x9d55
leaq 0x22930(%rip), %rsi     # 0x2c6a0
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
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 0x6530
leaq 0x228e0(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %r15d, %r15d
jle 0x9e05
leaq 0x24961(%rip), %r12     # 0x2e751
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
decl %r15d
jne 0x9df0
leaq 0x22899(%rip), %rsi     # 0x2c6a5
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6360
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
movq %rbx, %rdi
callq 0x6360
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6530
leaq 0x22822(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %r15d, %r15d
jle 0x9ec5
leaq 0x248a3(%rip), %r12     # 0x2e751
movl %r15d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x9eb1
leaq 0x227df(%rip), %rsi     # 0x2c6ab
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6360
movq 0x88(%r14), %rsi
movq 0x90(%r14), %rdx
movq %rbx, %rdi
callq 0x6360
movq %rax, %r12
leaq 0x225ff(%rip), %rsi     # 0x2c4f8
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rbx,%rax)
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x6530
leaq 0x22766(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %r15d, %r15d
jle 0x9f81
leaq 0x247e7(%rip), %r12     # 0x2e751
movl %r15d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x9f6d
leaq 0x22729(%rip), %rsi     # 0x2c6b1
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6360
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 0x6530
leaq 0x226ed(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %r15d, %r15d
jle 0x9ff8
leaq 0x2476e(%rip), %r12     # 0x2e751
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
decl %r15d
jne 0x9fe3
leaq 0x226bb(%rip), %rsi     # 0x2c6ba
movl $0xd, %edx
movq %rbx, %rdi
callq 0x6360
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_O1/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 0xa7a9
cmpl $0x0, 0x48(%rbx)
je 0xa875
leaq 0x33cb2(%rip), %r15     # 0x3e400
movq (%r15), %r14
addq $0x48, %r14
leaq 0x220e0(%rip), %rsi     # 0x2c83c
movl $0x12, %edx
movq %r14, %rdi
callq 0x6360
movq 0x50(%rbx), %rax
xorl %ecx, %ecx
cmpl $0x3, 0x10(%rax)
setne %cl
leaq 0x2210b(%rip), %rax     # 0x2c888
leaq 0x220cb(%rip), %rsi     # 0x2c84f
cmoveq %rax, %rsi
leaq 0x3(,%rcx,2), %rdx
movq %r14, %rdi
callq 0x6360
leaq 0x220b6(%rip), %rsi     # 0x2c855
movl $0x14, %edx
jmp 0xa85a
cmpl $0x6, %eax
jne 0xa7c4
cmpl $0x1, 0x48(%rbx)
jne 0xa87e
movl $0x6, 0x10(%rbx)
jmp 0xa878
leaq 0x33c35(%rip), %r15     # 0x3e400
movq (%r15), %r14
addq $0x48, %r14
leaq 0x22063(%rip), %rsi     # 0x2c83c
movl $0x12, %edx
movq %r14, %rdi
callq 0x6360
movq 0x50(%rbx), %rax
movslq 0x10(%rax), %rax
leaq 0x33c13(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6360
movq %rax, %r14
leaq 0x22054(%rip), %rsi     # 0x2c86a
movl $0xd, %edx
movq %rax, %rdi
callq 0x6360
xorl %eax, %eax
cmpl $0x1, 0x48(%rbx)
setne %al
leaq 0x22045(%rip), %rcx     # 0x2c878
leaq 0x22046(%rip), %rsi     # 0x2c880
cmoveq %rcx, %rsi
leaq 0x7(,%rax,4), %rdx
movq %r14, %rdi
callq 0x6360
leaq 0x26d42(%rip), %rsi     # 0x31597
movl $0x2, %edx
movq %r14, %rdi
callq 0x6360
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1a9e6
movl %eax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x33b7b(%rip), %r14     # 0x3e400
movq (%r14), %rdi
addq $0x48, %rdi
leaq 0x21f79(%rip), %rsi     # 0x2c80c
movl $0x2f, %edx
callq 0x6360
movq (%r14), %rdi
jmp 0xa865
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33450(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xb001
movq (%r14), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x23217(%rip), %rax     # 0x2e1ed
cmpq %rax, %rdi
je 0xaff5
movl $0x1, %ebp
cmpb $0x2a, (%rdi)
je 0xaff9
leaq 0x23201(%rip), %rsi     # 0x2e1ed
callq 0x6400
testl %eax, %eax
jne 0xaff9
movl 0x30(%r14), %ebp
movl %ebp, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x6340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x62e0
movq %rax, %r14
movq %rax, %rbx
movq 0x48(%r15), %rax
movslq 0x10(%rax), %r12
leaq 0x333c3(%rip), %rax     # 0x3e408
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 0x16c42
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x191bc
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xb091
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
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 0x16c42
leaq 0x3334f(%rip), %rdi     # 0x3e408
movq %r12, %rsi
callq 0x19ff4
movl %eax, %ebp
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0xb0da
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x62f0
testb %bpl, %bpl
je 0xb163
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 0x16c42
leaq 0x332fd(%rip), %rdi     # 0x3e408
movq %r12, %rsi
callq 0x1a09c
movl %eax, 0x10(%r15)
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xb12e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x62f0
leaq 0x32a5b(%rip), %rax     # 0x3db90
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %r14
cmpq %r14, %rdi
je 0xb154
movq (%r14), %rsi
incq %rsi
callq 0x62f0
movl $0x38, %esi
movq %rbx, %rdi
callq 0x62f0
jmp 0xb176
leaq 0x3329e(%rip), %rdi     # 0x3e408
movq %rbx, %rsi
callq 0x19f68
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 0xb1dc
movq 0x38(%rsp), %rsi
jmp 0xb1ab
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0xb1dc
movq 0x58(%rsp), %rsi
incq %rsi
jmp 0xb1d7
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xb1cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
jmp 0xb1cf
movq %rax, %r14
movl $0x38, %esi
movq %rbx, %rdi
callq 0x62f0
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb2c7
movq (%rdi), %rax
movzbl %dl, %edx
callq *0x10(%rax)
movq 0x48(%rbx), %rax
movslq 0x10(%rax), %rax
leaq 0x331f4(%rip), %r15     # 0x3e408
movq (%r15), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xb2d3
movq (%r14), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x22fa4(%rip), %rax     # 0x2e1da
cmpq %rax, %rdi
je 0xb2c0
cmpb $0x2a, (%rdi)
je 0xb254
leaq 0x22f8f(%rip), %rsi     # 0x2e1da
callq 0x6400
testl %eax, %eax
je 0xb2c0
leaq 0x331a5(%rip), %r12     # 0x3e400
movq (%r12), %r14
addq $0x48, %r14
leaq 0x216d7(%rip), %rsi     # 0x2c941
movl $0x23, %edx
movq %r14, %rdi
callq 0x6360
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 0x6360
leaq 0x262fa(%rip), %rsi     # 0x31597
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
movq (%r12), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1a9e6
movl $0x1, %eax
jmp 0xb2c4
movl 0x3c(%r14), %eax
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x6340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32dc0(%rip), %r14     # 0x3e408
movq %r14, %rdi
callq 0x1a092
testb %al, %al
je 0xb677
movl 0x10(%rbx), %esi
leaq 0x32daa(%rip), %rdi     # 0x3e408
callq 0x1a092
testb %al, %al
je 0xb677
cmpl $0x7, 0x48(%rbx)
je 0xb677
cmpl $0x7, 0x10(%rbx)
jne 0xb711
leaq 0x32d82(%rip), %r12     # 0x3e400
movq (%r12), %r15
addq $0x48, %r15
leaq 0x21316(%rip), %rsi     # 0x2c9a3
movl $0x35, %edx
movq %r15, %rdi
callq 0x6360
movslq 0x48(%rbx), %rax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r15, %rdi
callq 0x6360
movq %rax, %r15
leaq 0x2131a(%rip), %rsi     # 0x2c9d9
movl $0x5, %edx
movq %rax, %rdi
callq 0x6360
movslq 0x10(%rbx), %rax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r15, %rdi
callq 0x6360
leaq 0x25ea9(%rip), %rsi     # 0x31597
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
movq (%r12), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1a9e6
movl $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18596
movq %rax, %rbx
movq 0x98(%r14), %rdi
callq 0x17fde
movl %eax, 0x31e2a(%rip)     # 0x3e30c
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, 0x31e00(%rip)     # 0x3e30c
testq %rbx, %rbx
je 0xc52d
movq %rbx, %rdi
callq 0x166da
movl $0x48, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x62f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc9da
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0x80(%rbx), %rcx
testq %rcx, %rcx
je 0xcace
movq 0x78(%rbx), %rax
movl 0x10(%rax), %eax
testl %eax, %eax
je 0xcace
movl 0x10(%rcx), %ecx
testl %ecx, %ecx
je 0xcace
cmpl $0x1, %eax
je 0xcace
cmpl $0x1, %ecx
je 0xcace
cmpl %eax, %ecx
je 0xcace
leaq 0x319db(%rip), %r15     # 0x3e400
movq (%r15), %r14
addq $0x48, %r14
leaq 0x201f5(%rip), %rsi     # 0x2cc28
movl $0x20, %edx
movq %r14, %rdi
callq 0x6360
movq 0x80(%rbx), %rax
movslq 0x10(%rax), %rax
leaq 0x319b6(%rip), %r12     # 0x3e408
movq (%r12), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6360
movq %rax, %r14
leaq 0x201d5(%rip), %rsi     # 0x2cc49
movl $0x16, %edx
movq %rax, %rdi
callq 0x6360
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 0x6360
leaq 0x24aef(%rip), %rsi     # 0x31597
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1a9e6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq