LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3180a(%rip), %eax     # 0x3e30c
cmpl $0x2, %eax
setne %cl
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
sete %dl
orb %cl, %dl
je 0xcb85
testq %rdi, %rdi
sete %cl
cmpl $0x2, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xcbbe
leaq 0x318cc(%rip), %rax     # 0x3e400
movq (%rax), %r14
addq $0x48, %r14
leaq 0x20140(%rip), %rsi     # 0x2cc82
movl $0x1d, %edx
movq %r14, %rdi
callq 0x6360
movslq 0x317b6(%rip), %rax     # 0x3e30c
leaq 0x318ab(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6360
leaq 0x24a1c(%rip), %rsi     # 0x31597
movl $0x2, %edx
movq %rax, %rdi
jmp 0xcb9f
leaq 0x31874(%rip), %rax     # 0x3e400
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x200c6(%rip), %rsi     # 0x2cc60
movl $0x21, %edx
callq 0x6360
leaq 0x31855(%rip), %rax     # 0x3e400
movq (%rax), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1a9e6
testq %rdi, %rdi
sete %cl
cmpl $0x2, %eax
sete %al
orb %cl, %al
jne 0xcbe3
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x78(%rbx), %rax
movl 0x10(%rax), %eax
cmpl 0x3172b(%rip), %eax     # 0x3e30c
jne 0xcbe9
popq %rbx
popq %r14
popq %r15
retq
leaq 0x31810(%rip), %rax     # 0x3e400
movq (%rax), %r14
addq $0x48, %r14
leaq 0x20084(%rip), %rsi     # 0x2cc82
movl $0x1d, %edx
movq %r14, %rdi
callq 0x6360
movslq 0x316fa(%rip), %rax     # 0x3e30c
leaq 0x317ef(%rip), %r15     # 0x3e408
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6360
movq %rax, %r14
leaq 0x20066(%rip), %rsi     # 0x2cca0
movl $0x4, %edx
movq %rax, %rdi
callq 0x6360
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 0x6360
leaq 0x20038(%rip), %rsi     # 0x2cca5
movl $0xb, %edx
jmp 0xcb80
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xccd0
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x78(%r14), %rax
cmpl $0x6, 0x10(%rax)
je 0xccd0
leaq 0x3175a(%rip), %r15     # 0x3e400
movq (%r15), %rdi
addq $0x48, %rdi
leaq 0x1fffd(%rip), %rsi     # 0x2ccb1
movl $0x14, %edx
callq 0x6360
movq (%r15), %rdi
movq 0x78(%r14), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x1a9e6
movq %rbx, %rdi
callq 0x18596
movq %rax, %r15
movq 0x80(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x8(%rax)
testq %r15, %r15
je 0xcd05
movq %r15, %rdi
callq 0x166da
movl $0x48, %esi
movq %r15, %rdi
callq 0x62f0
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0xcd22
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_O1/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 0xcd83
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0x78(%rbx), %rax
movl 0x10(%rax), %eax
cmpl $0x1, %eax
je 0xcd83
cmpl $0x6, %eax
je 0xcd83
leaq 0x316a3(%rip), %r15     # 0x3e400
movq (%r15), %rdi
addq $0x48, %rdi
leaq 0x1ff46(%rip), %rsi     # 0x2ccb1
movl $0x14, %edx
callq 0x6360
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1a9e6
movq %r14, %rdi
callq 0x18596
movq %rax, %r14
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
testq %r14, %r14
je 0xcdbd
movq %r14, %rdi
callq 0x166da
movl $0x48, %esi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x62f0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcdea
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0xcdff
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0xcf57
movl 0x10(%rax), %eax
cmpl $0x1, %eax
je 0xcf57
movq 0xb0(%rbx), %rcx
testq %rcx, %rcx
je 0xcf57
movl 0x10(%rcx), %ecx
cmpl $0x1, %ecx
je 0xcf57
cmpl %ecx, %eax
jne 0xce66
cmpl $0x6, %eax
ja 0xce4a
movl $0x68, %ecx
btl %eax, %ecx
jb 0xce9a
leaq 0x315af(%rip), %rax     # 0x3e400
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x1fe91(%rip), %rsi     # 0x2ccf0
movl $0x30, %edx
jmp 0xce80
leaq 0x31593(%rip), %rax     # 0x3e400
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x1fe4b(%rip), %rsi     # 0x2ccc6
movl $0x29, %edx
callq 0x6360
leaq 0x31574(%rip), %rax     # 0x3e400
movq (%rax), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1a9e6
movq %r14, %rdi
callq 0x18596
movq %rax, %r14
movl $0x78, %edi
callq 0x62e0
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 0x16c42
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 0x17f0e
movq %r15, 0x98(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xcf23
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq 0x98(%rbx), %rsi
movq %r14, %rdi
callq 0x184aa
movq 0xb8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x166da
movl $0x48, %esi
movq %r14, %rdi
callq 0x62f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xcf82
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
jmp 0xcf82
movq %rax, %rbx
movl $0x78, %esi
movq %r15, %rdi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16c42
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x183ae
movq %rax, 0x98(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xcffd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq 0x98(%rbx), %rax
testq %rax, %rax
je 0xd104
cmpb $0x1, 0x31(%rax)
jne 0xd15b
leaq 0x313e2(%rip), %r12     # 0x3e400
movq (%r12), %r14
addq $0x48, %r14
leaq 0x1f85f(%rip), %rsi     # 0x2c88c
movl $0xf, %edx
movq %r14, %rdi
callq 0x6360
movq 0x98(%rbx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x17fb8
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x6360
movq %rax, %r14
leaq 0x1f835(%rip), %rsi     # 0x2c89c
movl $0x1c, %edx
movq %rax, %rdi
callq 0x6360
movq 0x98(%rbx), %rdi
callq 0x17fe2
movq %r14, %rdi
movl %eax, %esi
callq 0x6530
leaq 0x7(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
movq %rax, %r14
movq 0x98(%rbx), %rdi
callq 0x17fe6
movq %r14, %rdi
movl %eax, %esi
callq 0x6530
leaq 0x7(%rsp), %rsi
movb $0x2e, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd0e8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x62f0
movq (%r12), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1a9e6
movq $0x0, 0x98(%rbx)
jmp 0xd15b
leaq 0x312f5(%rip), %r15     # 0x3e400
movq (%r15), %r14
addq $0x48, %r14
leaq 0x1f773(%rip), %rsi     # 0x2c88c
movl $0xf, %edx
movq %r14, %rdi
callq 0x6360
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rdx
movq %r14, %rdi
callq 0x6360
leaq 0x1f7c1(%rip), %rsi     # 0x2c901
movl $0x1a, %edx
movq %rax, %rdi
callq 0x6360
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x1a9e6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xd199
movq 0x18(%rsp), %rsi
jmp 0xd191
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd199
movq 0x38(%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/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 0x1011a
movq 0x50(%rbx), %rdx
addq $0x18, %rdx
leaq 0x30(%rbx), %rdi
cmpq %rdx, %rdi
je 0x100fa
movq (%rdx), %rsi
callq 0x16cd2
movq 0x50(%rbx), %rdx
addq $0x30, %rdx
addq $0x18, %rbx
cmpq %rdx, %rbx
je 0x10116
movq (%rdx), %rsi
movq %rbx, %rdi
callq 0x16cd2
xorl %ebx, %ebx
jmp 0x10183
movq %rax, %r15
movl $0x18, %edi
callq 0x62e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1cfb4
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1d347(%rip), %rsi     # 0x2d489
leaq 0x1d35d(%rip), %rdx     # 0x2d4a6
movq %rsp, %r12
movq %r12, %rdi
callq 0x6fec
movq %r14, %rdi
movl $0x15, %esi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x2ae24
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x10183
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
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 0x101ba
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0x101b5
movq %rax, %r14
movl $0x18, %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/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 0x1686a
movq %rbx, %rdi
callq 0x2af04
movl %eax, %ebp
movl $0x18, %edi
callq 0x62e0
movl %ebp, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x6080
incq (%r15)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ce80(%rip), %rsi     # 0x2d4d4
leaq 0x1ce96(%rip), %rdx     # 0x2d4f1
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6fec
movq %rbx, %rdi
movl $0x16, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2ae24
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x10696
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
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 0x106bd
movq 0x18(%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/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 0x107a1
movq %rdx, %r13
movq %rdi, %r15
movl $0x18, %edi
callq 0x62e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1cfb4
movl $0x18, %edi
callq 0x62e0
movq %rax, %r12
movl (%r13), %esi
movq %rax, %rdi
movl $0x2, %edx
callq 0x1cfca
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x1cdd9(%rip), %rsi     # 0x2d534
leaq 0x1ce1a(%rip), %rdx     # 0x2d57c
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x6fec
movq %r15, %rdi
movl $0x11, %esi
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x2ae24
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x107a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
jmp 0x107a4
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 0x107ea
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x107e5
movq %rax, %r14
movl $0x18, %esi
movq %r12, %rdi
jmp 0x107e5
movq %rax, %r14
movl $0x18, %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/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 0x62e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1cfb4
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x106f8
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1cca3(%rip), %rsi     # 0x2d57d
leaq 0x1ccb3(%rip), %rdx     # 0x2d594
movq %rsp, %r12
movq %r12, %rdi
callq 0x6fec
movq %r14, %rdi
movl $0x4, %esi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x2ae24
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1091b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
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 0x10952
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0x1094d
movq %rax, %r14
movl $0x18, %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/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 0x62e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1cfb4
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x106f8
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1cbcf(%rip), %rsi     # 0x2d57f
leaq 0x1cbdd(%rip), %rdx     # 0x2d594
movq %rsp, %r12
movq %r12, %rdi
callq 0x6fec
movq %r14, %rdi
movl $0x3, %esi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x2ae24
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x109f1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
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 0x10a28
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0x10a23
movq %rax, %r14
movl $0x18, %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/to_tac.cpp
// Function: AST_array_access::gen_tac_lval(Tac*, int*)
opd *AST_array_access::gen_tac_lval(Tac* t, int *sta_base){
    int arr_base = 0;
    opd **ind_addr = new opd*();
    *ind_addr = 0;// indicar que alguien va a tener que colocar aquí la dirección apropiada
    opd *din_base = gen_tac_arr(t, sta_base, ind_addr, &arr_base);

    type_descriptor* ad = types.types[ type ];
    *sta_base -= arr_base * ad->width;

    //TODO esto debe hacerse sobre temporales distintos
    // multiplicar la suma de índices por el ancho de lo que alberga el arreglo
    t->append_quad(inst::MUL, *ind_addr, *ind_addr, new opd(ad->width), "multiplicar el aplanamiento de índices por el ancho del tipo");

    // sumar la posición del arreglo (din_base) con el índice dinámico (ind_base)
    t->append_quad(inst::ADD, *ind_addr, din_base, *ind_addr, "sumar la base del arreglo con el desplazamiento hasta la posición solicitada");

    din_base = *ind_addr;
    delete ind_addr;

    return din_base;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
leaq 0x14(%rsp), %rbp
movl $0x0, (%rbp)
movl $0x8, %edi
callq 0x62e0
movq %rax, %rbx
movq $0x0, (%rax)
movq (%r13), %rax
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %rbp, %r8
callq *0x40(%rax)
movq %rax, 0x8(%rsp)
movslq 0x10(%r13), %rax
leaq 0x2d97b(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r15
movl 0x28(%r15), %eax
imull (%rbp), %eax
subl %eax, (%r12)
movq (%rbx), %r13
movl $0x18, %edi
callq 0x62e0
movq %rax, %r12
movl 0x28(%r15), %esi
movq %rax, %rdi
movl $0x2, %edx
callq 0x1cfca
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1cac4(%rip), %rsi     # 0x2d595
leaq 0x1cafa(%rip), %rdx     # 0x2d5d2
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
callq 0x6fec
movq %r14, %rdi
movl $0x13, %esi
movq %r13, %rdx
movq %r13, %rcx
movq %r12, %r8
movq %rbp, %r9
callq 0x2ae24
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x10b15
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x62f0
movq (%rbx), %r12
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1caab(%rip), %rsi     # 0x2d5d3
leaq 0x1caf1(%rip), %rdx     # 0x2d620
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x6fec
movq %r14, %rdi
movl $0x11, %esi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x2ae24
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x10b6e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x62f0
movq (%rbx), %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x62f0
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x10bcb
movq 0x28(%rsp), %rsi
jmp 0x10bb6
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x10bcb
movq 0x48(%rsp), %rsi
incq %rsi
jmp 0x10bc6
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_rlval::to_tac(Tac*)
opd *AST_rlval::to_tac(Tac* t) {
    opd *l = value->to_tac(t);
    if ( value->type == BOOLEAN ){
        truelist.push_back( t->next_instruction() );
        t->append_quad(inst::IF, l, 0, 0, "identificador de tipo booleano (true)");
        falselist.push_back( t->next_instruction() );
        t->append_quad(inst::GOTO, 0, 0, 0, "identificador de tipo booleano (false)");
    }
    return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rbx
movq 0x48(%r15), %rax
cmpl $0x6, 0x10(%rax)
jne 0x11628
leaq 0x18(%r15), %r12
movq %r14, %rdi
callq 0x2af04
movl %eax, %ebp
movl $0x18, %edi
callq 0x62e0
movl %ebp, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x6080
incq 0x28(%r15)
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1c3ca(%rip), %rsi     # 0x2d933
leaq 0x1c3e8(%rip), %rdx     # 0x2d958
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x6fec
movq %r14, %rdi
movl $0x17, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x2ae24
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x115ac
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x62f0
leaq 0x30(%r15), %r12
movq %r14, %rdi
callq 0x2af04
movl %eax, %ebp
movl $0x18, %edi
callq 0x62e0
movl %ebp, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x6080
incq 0x40(%r15)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1c373(%rip), %rsi     # 0x2d959
leaq 0x1c392(%rip), %rdx     # 0x2d97f
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6fec
movq %r14, %rdi
movl $0x16, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x2ae24
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11628
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x1164c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1165d
movq (%r13), %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/to_tac.cpp
// Function: AST_function_call::to_tac(Tac*)
opd *AST_function_call::to_tac(Tac* t){
    params->to_tac(t);
    if (returns_value) {
        opd *o = new opd();
        t->append_quad(inst::CALL, o, new opd(sym), 0, "llamada de función guardada en el primer argumento");
        return o;
    }
    t->append_quad(inst::EXEC, new opd(sym), 0, 0, "llamada de función guardada en el primer argumento");
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq 0x80(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb 0x78(%r12), %bpl
movl $0x18, %edi
callq 0x62e0
movq %rax, %rbx
cmpb $0x1, %bpl
jne 0x11c99
movq %rbx, %rdi
callq 0x1cfb4
movl $0x18, %edi
callq 0x62e0
movq %rax, %r15
movq 0x70(%r12), %rsi
movq %rax, %rdi
callq 0x1cfac
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1be16(%rip), %rsi     # 0x2da7b
leaq 0x1be42(%rip), %rdx     # 0x2daae
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x6fec
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x2ae24
movq 0x28(%rsp), %rdi
jmp 0x11ce9
movq 0x70(%r12), %rsi
movq %rbx, %rdi
callq 0x1cfac
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1bdc5(%rip), %rsi     # 0x2da7b
leaq 0x1bdf1(%rip), %rdx     # 0x2daae
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6fec
movq %r14, %rdi
movl $0x8, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x2ae24
movq 0x8(%rsp), %rdi
xorl %ebx, %ebx
cmpq %r13, %rdi
je 0x11cfa
movq (%r13), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rax
addq $0x48, %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 0x11d56
movq 0x38(%rsp), %rsi
jmp 0x11d32
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11d56
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x11d51
movq %rax, %r14
movl $0x18, %esi
movq %r15, %rdi
jmp 0x11d51
jmp 0x11d46
movq %rax, %r14
movl $0x18, %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/to_tac.cpp
// Function: AST_loop::to_tac(Tac*)
void AST_loop::to_tac(Tac* t){
    next_list.clear();
    int start_instr = t->next_instruction(); // etiqueta para el salto de la
                                            // ultima instruccion del loop
    
    expr->to_tac(t);
    t->backpatch(expr->truelist, t->next_instruction());
    blck->to_tac(t);
    
    // enviar los saltos de los continue hasta el principio del codigo de
    // evaluacion de la condicion
    t->backpatch(blck->continue_list, start_instr);
    
    t->append_quad(inst::GOTO, 0, 0, new opd(start_instr, O_LABEL), "salto condicional de un loop");
    
    next_list = expr->falselist;
    next_list.splice(next_list.end(), blck->break_list);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x1686a
movq %r15, %rdi
callq 0x2af04
movl %eax, %ebp
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x18(%rax)
movq 0x78(%rbx), %r12
addq $0x18, %r12
movq %r15, %rdi
callq 0x2af04
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x2af0e
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
movq 0x80(%rbx), %rsi
addq $0x30, %rsi
movq %r15, %rdi
movl %ebp, %edx
callq 0x2af0e
movl $0x18, %edi
callq 0x62e0
movq %rax, %r12
movq %rax, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0x1cfca
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x1a7db(%rip), %rsi     # 0x2ddb2
leaq 0x1a7f0(%rip), %rdx     # 0x2ddce
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x6fec
movq %r15, %rdi
movl $0x16, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r12, %r8
movq %r13, %r9
callq 0x2ae24
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x13619
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq 0x78(%rbx), %rdx
addq $0x30, %rdx
cmpq %rdx, %r14
je 0x13631
movq (%rdx), %rsi
movq %r14, %rdi
callq 0x16cd2
movq 0x80(%rbx), %r15
leaq 0x48(%r15), %rdx
movq 0x48(%r15), %rsi
cmpq %rdx, %rsi
je 0x1365d
movq %r14, %rdi
callq 0x6160
movq 0x58(%r15), %rax
addq %rax, 0x28(%rbx)
movq $0x0, 0x58(%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x13693
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x1368e
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_un_op::AST_un_op(tokenId*, AST_expression*)
AST_un_op::AST_un_op(tokenId* o, AST_expression* e){
    
    is_constant = false;
    type = UNDEFINED;
    
    if ( o->ident.compare("!") == 0 ){
        oper_type = NOT;
    } else if ( o->ident.compare("-") == 0 ){
        oper_type = NEG;
    } else {
        throw "Error de implementación en identificación de operador de expresión unaria";
    }
    
    line = o->line;
    column = o->column;
    delete o;

    expr = e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %r13d, %r13d
movq %r13, 0x28(%rdi)
leaq 0x30(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x30(%rdi)
movq %r13, 0x40(%rdi)
leaq 0x28864(%rip), %rax     # 0x3d028
movq %rax, (%rdi)
movb $0x0, 0x14(%rdi)
movl $0x0, 0x10(%rdi)
leaq 0x8(%rsi), %r12
leaq 0x1d351(%rip), %rsi     # 0x31b2e
movq %r12, %rdi
callq 0x60d0
testl %eax, %eax
je 0x14821
leaq 0x19f29(%rip), %rsi     # 0x2e719
movq %r12, %rdi
callq 0x60d0
testl %eax, %eax
je 0x14827
movl $0x8, %edi
callq 0x6150
leaq 0x198da(%rip), %rcx     # 0x2e0e7
movq %rcx, (%rax)
movq 0x29789(%rip), %rsi     # 0x3dfa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6520
movl $0x1, %r13d
movl %r13d, 0x48(%rbx)
movq (%r15), %rax
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%r15)
movq 0x8(%r15), %rax
movb $0x0, (%rax)
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0x14859
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %r15, %rdi
callq 0x62f0
movq %r14, 0x50(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x16922
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_int::AST_int(tokenInt*)
AST_int::AST_int(tokenInt* tk){
    
    type = INT;
    is_constant = true;
    
    line = tk->line;
    column = tk->column;
    value = tk->number;
    delete tk;
}

// Assembly:
movq %rsi, %rax
leaq 0x18(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rcx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
leaq 0x30(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rdx, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
leaq 0x287bc(%rip), %rcx     # 0x3d070
movq %rcx, (%rdi)
movl $0x3, 0x10(%rdi)
movb $0x1, 0x14(%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl 0x8(%rsi), %ecx
movl %ecx, 0x48(%rdi)
movl $0xc, %esi
movq %rax, %rdi
jmp 0x62f0
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_float::AST_float(tokenFloat*)
AST_float::AST_float(tokenFloat* tk){

    type = FLOAT;
    is_constant = true;
    
    line = tk->line;
    column = tk->column;
    value = tk->number;
    delete tk;
}

// Assembly:
movq %rsi, %rax
leaq 0x18(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rcx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
leaq 0x30(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rdx, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
leaq 0x287b0(%rip), %rcx     # 0x3d0b8
movq %rcx, (%rdi)
movl $0x4, 0x10(%rdi)
movb $0x1, 0x14(%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movss 0x8(%rsi), %xmm0
movss %xmm0, 0x48(%rdi)
movl $0xc, %esi
movq %rax, %rdi
jmp 0x62f0
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_boolean::AST_boolean(tokenBoolean*)
AST_boolean::AST_boolean(tokenBoolean* tk){
    
    type = BOOLEAN;
    is_constant = true;
    
    line = tk->line;
    column = tk->column;
    value = tk->value;
    delete tk;
}

// Assembly:
movq %rsi, %rax
leaq 0x18(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rcx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
leaq 0x30(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rdx, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
leaq 0x287a0(%rip), %rcx     # 0x3d100
movq %rcx, (%rdi)
movl $0x6, 0x10(%rdi)
movb $0x1, 0x14(%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movb 0x8(%rsi), %cl
movb %cl, 0x48(%rdi)
movl $0xc, %esi
movq %rax, %rdi
jmp 0x62f0
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_char::AST_char(tokenId*)
AST_char::AST_char(tokenId* tk){

    type = CHAR;
    is_constant = true;
    
    line = tk->line;
    column = tk->column;
    value = tk->ident + "";
    value = value.substr(1, value.length() - 2);
    delete tk;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x28783(%rip), %rcx     # 0x3d148
movq %rcx, (%rdi)
leaq 0x48(%rdi), %r15
leaq 0x58(%rdi), %r13
movq %r13, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb $0x0, 0x58(%rdi)
movl $0x5, 0x10(%rdi)
movb $0x1, 0x14(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x16c42
leaq 0x1996f(%rip), %rsi     # 0x2e382
leaq 0x8(%rsp), %rdi
callq 0x65a0
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63c0
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x14a43
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq 0x50(%rbx), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x6310
leaq 0x8(%rsp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x63c0
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0x14a82
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq $0x0, 0x10(%r14)
movq 0x8(%r14), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x14aa9
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %r14, %rdi
callq 0x62f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14ae3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x14ae6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
jmp 0x14ae6
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x14afa
movq (%r13), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x16922
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_string::AST_string(tokenId*)
AST_string::AST_string(tokenId* tk){

    is_constant = true;
    
    line = tk->line;
    column = tk->column;
    value = tk->ident + "";

    value = value.substr(1, value.length() - 2);
    type = STRING;
    delete tk;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x28649(%rip), %rcx     # 0x3d190
movq %rcx, (%rdi)
leaq 0x48(%rdi), %r15
leaq 0x58(%rdi), %r13
movq %r13, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb $0x0, 0x58(%rdi)
movb $0x1, 0x14(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x16c42
leaq 0x197f4(%rip), %rsi     # 0x2e382
leaq 0x8(%rsp), %rdi
callq 0x65a0
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63c0
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x14bbe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq 0x50(%rbx), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x6310
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63c0
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x14bfe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movl $0x7, 0x10(%rbx)
movq $0x0, 0x10(%r14)
movq 0x8(%r14), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x14c2c
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %r14, %rdi
callq 0x62f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14c66
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x14c69
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
jmp 0x14c69
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x14c7d
movq (%r13), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x16922
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_enum_constant::AST_enum_constant(tokenConstant*)
AST_enum_constant::AST_enum_constant(tokenConstant* tk){

    is_constant = true;
    
    line = tk->line;
    column = tk->column;
    value = tk->ident;

    type = tk->type;
    delete tk;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x2851b(%rip), %rcx     # 0x3d1e0
movq %rcx, (%rdi)
leaq 0x48(%rdi), %r15
leaq 0x58(%rdi), %r12
movq %r12, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb $0x0, 0x58(%rdi)
movb $0x1, 0x14(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
addq $0x8, %rsi
movq %r15, %rdi
callq 0x6180
movl 0x28(%r14), %eax
movl %eax, 0x10(%rbx)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x14d12
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x30, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x62f0
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x14d41
movq (%r12), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x16922
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_string::append(tokenId*)
void AST_string::append(tokenId* tk){
    is_constant = true;
    string c = tk->ident;
    value += c.substr(1, c.length() - 2);
    delete tk;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x14(%rdi)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsi), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x16c42
movq 0x8(%r15), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x6310
addq $0x48, %r14
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x60f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14dd4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
testq %rbx, %rbx
je 0x14e0d
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x14e00
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %rbx, %rdi
callq 0x62f0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x14e24
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x62f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14e53
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
jmp 0x14e53
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x14e6a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_ident::AST_ident(tokenId*)
AST_ident::AST_ident(tokenId* tk){

    type = UNDEFINED;
    is_constant = false;
    
    line = tk->line;
    column = tk->column;
    value = string(tk->ident);
    delete tk;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x2837a(%rip), %rcx     # 0x3d228
movq %rcx, (%rdi)
leaq 0x48(%rdi), %r15
leaq 0x58(%rdi), %r12
movq %r12, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
movl $0x0, 0x10(%rdi)
movb %al, 0x14(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rsi), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x16c42
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x63c0
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x14f14
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x14f3b
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %rbx, %rdi
callq 0x62f0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x14f6d
movq (%r12), %rsi
incq %rsi
callq 0x62f0
movq %r14, %rdi
callq 0x16922
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_struct_access::AST_struct_access(AST_lval*, tokenId*)
AST_struct_access::AST_struct_access( AST_lval* lvalue, tokenId* f){
    is_constant = false;
    value = lvalue;
    line = f->line;
    column = f->column;
    
    field = f->ident;
    
    delete f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x28315(%rip), %rcx     # 0x3d388
movq %rcx, (%rdi)
leaq 0x50(%rdi), %r15
leaq 0x60(%rdi), %r12
movq %r12, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
movb %al, 0x14(%rdi)
movq %rsi, 0x48(%rdi)
movq (%rdx), %rax
movq %rax, 0x8(%rdi)
leaq 0x8(%rdx), %rsi
movq %r15, %rdi
callq 0x6180
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x150ca
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x62f0
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x150f9
movq (%r12), %rsi
incq %rsi
callq 0x62f0
movq %r14, %rdi
callq 0x16922
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_parameters_list::add_element(AST_expression*)
void AST_parameters_list::add_element( AST_expression* e ){
    if ( elem.empty() ) {
        line = e->line;
        column = e->column;
    }

    elem.push_back( e );
}

// Assembly:
pushq %rax
movq %rsi, %rax
movq %rsi, (%rsp)
movq 0x18(%rdi), %rsi
cmpq %rsi, 0x10(%rdi)
jne 0x1518c
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
cmpq 0x20(%rdi), %rsi
je 0x1519c
movq %rax, (%rsi)
addq $0x8, 0x18(%rdi)
jmp 0x151a8
addq $0x10, %rdi
movq %rsp, %rdx
callq 0x17686
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_function_call::AST_function_call(tokenId*, AST_parameters_list*)
AST_function_call::AST_function_call(tokenId* tk, AST_parameters_list* p){
    
    is_constant = false;
    returns_value = true;// en principio se asume que sí. AST_procedure lo quitará de hacer falta
    
    line = tk->line;
    column = tk->column;
    name = string(tk->ident);
    delete tk;
    
    params = p;
    has_return = NO;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x2827e(%rip), %rcx     # 0x3d468
movq %rcx, (%rdi)
leaq 0x50(%rdi), %r12
leaq 0x60(%rdi), %r13
movq %r13, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
movb %al, 0x14(%rdi)
movb $0x1, 0x78(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x8(%rsi), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x16c42
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x63c0
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x15252
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq $0x0, 0x10(%r15)
movq 0x8(%r15), %rax
movb $0x0, (%rax)
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0x15279
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %r15, %rdi
callq 0x62f0
movq %r14, 0x80(%rbx)
movl $0x1, 0x48(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x152bb
movq (%r13), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x16922
movq %r14, %rdi
callq 0x6550
nop