LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%rbp)
pushq $0x8
popq %rdi
callq 0x62d0
movq %rax, %rbx
andq $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 0x2a3af(%rip), %rcx     # 0x38408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r15
movl 0x28(%r15), %eax
imull (%rbp), %eax
subl %eax, (%r12)
movq (%rbx), %r13
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %r12
movl 0x28(%r15), %esi
pushq $0x2
popq %rdx
movq %rax, %rdi
callq 0x1815e
leaq 0x16505(%rip), %rsi     # 0x24595
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6d6c
pushq $0x13
popq %rsi
leaq 0x38(%rsp), %r9
movq %r14, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0x212de
leaq 0x38(%rsp), %rdi
callq 0x65c8
movq (%rbx), %r12
leaq 0x16507(%rip), %rsi     # 0x245d3
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6d6c
pushq $0x11
popq %rsi
leaq 0x18(%rsp), %r9
movq %r14, %rdi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq %r12, %r8
callq 0x212de
leaq 0x18(%rsp), %rdi
callq 0x65c8
movq (%rbx), %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x62e0
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0xe134
jmp 0xe13b
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x65c8
jmp 0xe14e
movq %rax, %rbx
jmp 0xe14e
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
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 0xe901
leaq 0x18(%r15), %r12
movq %r14, %rdi
callq 0x2138a
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %r12, %rdi
callq 0x1243c
leaq 0x160b5(%rip), %rsi     # 0x24933
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x6d6c
pushq $0x17
popq %rsi
leaq 0x28(%rsp), %r9
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x212de
leaq 0x28(%rsp), %rdi
callq 0x65c8
addq $0x30, %r15
movq %r14, %rdi
callq 0x2138a
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x1243c
leaq 0x16088(%rip), %rsi     # 0x24959
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x6d6c
pushq $0x16
popq %rsi
leaq 0x8(%rsp), %r9
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x212de
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xe924
jmp 0xe92b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x65c8
jmp 0xe92e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq 0x80(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb 0x78(%r12), %bpl
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %rbx
cmpb $0x1, %bpl
jne 0xed48
movq %rbx, %rdi
callq 0x18148
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %r15
movq 0x70(%r12), %rsi
movq %rax, %rdi
callq 0x18140
leaq 0x15d67(%rip), %rsi     # 0x24a7b
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
pushq $0x1
popq %rsi
leaq 0x30(%rsp), %r9
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x212de
leaq 0x30(%rsp), %rdi
callq 0x65c8
jmp 0xed8f
movq 0x70(%r12), %rsi
movq %rbx, %rdi
callq 0x18140
leaq 0x15d1f(%rip), %rsi     # 0x24a7b
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
pushq $0x8
popq %rsi
leaq 0x10(%rsp), %r9
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x212de
leaq 0x10(%rsp), %rdi
callq 0x65c8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0xedb1
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x65c8
jmp 0xedda
jmp 0xedba
movq %rax, %r14
jmp 0xedda
movq %rax, %r14
pushq $0x18
popq %rsi
movq %r15, %rdi
jmp 0xedd5
jmp 0xedcc
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x62e0
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_block::to_tac(Tac*)
void AST_block::to_tac(Tac* t){
    uint nsize = statements.size();
    
    for ( uint i = 0; i != nsize; i++){
        if ( i > 0 ){
            t->backpatch(statements[i-1]->next_list, t->next_instruction());
        }
        statements[i]->to_tac(t);
        
        continue_list.splice(continue_list.end(), statements[i]->continue_list);
        return_list.splice(return_list.end(), statements[i]->return_list);
        break_list.splice(break_list.end(), statements[i]->break_list);
    }
    if ( nsize > 0 ){
        next_list = statements.back()->next_list;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x88(%rdi), %rax
subq 0x80(%rdi), %rax
shrq $0x3, %rax
leaq 0x30(%rdi), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x60(%rdi), %r12
leaq 0x48(%rdi), %r13
movq %rax, (%rsp)
movl %eax, %eax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
cmpq %r15, 0x10(%rsp)
je 0xeec8
movq 0x80(%rbx), %rax
testq %r15, %r15
je 0xee63
movq -0x8(%rax,%r15,8), %rbp
addq $0x18, %rbp
movq %r14, %rdi
callq 0x2138a
movq %r14, %rdi
movq %rbp, %rsi
movl %eax, %edx
callq 0x21394
movq 0x80(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq 0x80(%rbx), %rax
movq (%rax,%r15,8), %rdx
addq $0x30, %rdx
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
callq 0x128e0
movq 0x80(%rbx), %rax
movq (%rax,%r15,8), %rdx
addq $0x60, %rdx
movq %r12, %rdi
movq %r12, %rsi
callq 0x128e0
movq 0x80(%rbx), %rax
movq (%rax,%r15,8), %rdx
addq $0x48, %rdx
movq %r13, %rdi
movq %r13, %rsi
callq 0x128e0
incq %r15
jmp 0xee27
cmpl $0x0, (%rsp)
je 0xeef7
movq 0x88(%rbx), %rax
movq -0x8(%rax), %rsi
addq $0x18, %rsi
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12420
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_function::to_tac(Tac*)
void AST_function::to_tac(Tac* t){
    
    func_to_prologue[func->getName()] = t->next_instruction();
    t->append_quad(inst::PROLOGUE,  0, 0, new opd(func),
                            "prologo de funcion " + func->getName()
                  );
    
    instructions->to_tac(t);
    
    t->backpatch( instructions->next_list, t->next_instruction() );
    t->backpatch( instructions->return_list, t->next_instruction() );
    
    func_to_epilogue[func->getName()] = t->next_instruction();
    t->append_quad(inst::EPILOGUE,  0, 0, new opd(func),
                            "epilogo de funcion " + func->getName()
                  );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2138a
movl %eax, %ebp
movq 0x98(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x13efa
leaq 0x28db9(%rip), %rdi     # 0x38310
movq %r15, %rsi
callq 0x12504
movl %ebp, (%rax)
movq %rsp, %rdi
callq 0x65c8
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %r15
movq 0x98(%r14), %rsi
movq %rax, %rdi
callq 0x18140
movq 0x98(%r14), %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x13efa
leaq 0x1572f(%rip), %rsi     # 0x24ccb
leaq 0x40(%rsp), %rdi
movq %r12, %rdx
callq 0x1256a
pushq $0xe
popq %rsi
leaq 0x40(%rsp), %r9
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x212de
leaq 0x40(%rsp), %rdi
callq 0x65c8
movq %rsp, %rdi
callq 0x65c8
movq 0xa8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq 0xa8(%r14), %r15
addq $0x18, %r15
movq %rbx, %rdi
callq 0x2138a
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x21394
movq 0xa8(%r14), %r15
addq $0x60, %r15
movq %rbx, %rdi
callq 0x2138a
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x21394
movq %rbx, %rdi
callq 0x2138a
movl %eax, %ebp
movq 0x98(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x13efa
leaq 0x28cfb(%rip), %rdi     # 0x38340
movq %r15, %rsi
callq 0x12504
movl %ebp, (%rax)
movq %rsp, %rdi
callq 0x65c8
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %r15
movq 0x98(%r14), %rsi
movq %rax, %rdi
callq 0x18140
movq 0x98(%r14), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x13efa
leaq 0x15655(%rip), %rsi     # 0x24cdf
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x1256a
pushq $0xf
popq %rsi
leaq 0x20(%rsp), %r9
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x212de
leaq 0x20(%rsp), %rdi
callq 0x65c8
movq %rsp, %rdi
callq 0x65c8
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0xf6e5
jmp 0xf6fe
jmp 0xf6ee
jmp 0xf6fe
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x65c8
jmp 0xf701
jmp 0xf6fe
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x62e0
jmp 0xf709
movq %rax, %rbx
movq %rsp, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x124ce
movq %r15, %rdi
callq 0x2138a
movl %eax, %ebp
movq 0x78(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x18(%rax)
movq 0x78(%r14), %r12
addq $0x18, %r12
movq %r15, %rdi
callq 0x2138a
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x21394
movq 0x80(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
movq 0x80(%r14), %rsi
addq $0x30, %rsi
movq %r15, %rdi
movl %ebp, %edx
callq 0x21394
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %r12
pushq $0x6
popq %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x1815e
leaq 0x14dfa(%rip), %rsi     # 0x24db2
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
pushq $0x16
popq %rsi
leaq 0x10(%rsp), %r9
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x212de
leaq 0x10(%rsp), %rdi
callq 0x65c8
movq 0x78(%r14), %rsi
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x12420
movq 0x80(%r14), %rdx
addq $0x48, %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x128e0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x65c8
jmp 0x1003d
movq %rax, %rbx
jmp 0x1003d
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movq %rdx, %r14
leaq 0x30(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
movq %rsi, %r15
leaq 0x26314(%rip), %rax     # 0x37068
movq %rax, (%rdi)
movb $0x0, 0x14(%rdi)
andl $0x0, 0x10(%rdi)
leaq 0x8(%rsi), %r12
leaq 0x17dc4(%rip), %rsi     # 0x28b2e
movq %r12, %rdi
callq 0x60d0
testl %eax, %eax
je 0x10dae
leaq 0x1498c(%rip), %rsi     # 0x25709
movq %r12, %rdi
callq 0x60d0
xorl %ecx, %ecx
testl %eax, %eax
je 0x10db1
pushq $0x8
popq %rdi
callq 0x6140
leaq 0x1434d(%rip), %rcx     # 0x250e7
movq %rcx, (%rax)
movq 0x27204(%rip), %rsi     # 0x37fa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x6500
pushq $0x1
popq %rcx
movl %ecx, 0x48(%rbx)
movq (%r15), %rax
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x62e0
movq %r14, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x125fa
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x30(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
leaq 0x26265(%rip), %rax     # 0x37188
movq %rax, (%rdi)
leaq 0x58(%rdi), %rax
movq %rax, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
movq %rsi, %r14
leaq 0x48(%rdi), %r15
movb $0x0, 0x58(%rdi)
movl $0x5, 0x10(%rdi)
movb $0x1, 0x14(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
addq $0x8, %rsi
leaq 0x14417(%rip), %rdx     # 0x25372
leaq 0x8(%rsp), %rdi
callq 0x125c2
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6390
movq %r12, %rdi
callq 0x65c8
movq 0x50(%rbx), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
callq 0x62f0
leaq 0x8(%rsp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6390
movq %rbx, %rdi
callq 0x65c8
movq %r14, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x62e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x10fce
movq %rax, %r14
movq %r15, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x125fa
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %r14
leaq 0x30(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
leaq 0x261ac(%rip), %rax     # 0x371d0
movq %rax, (%rdi)
leaq 0x48(%rdi), %r15
leaq 0x58(%rdi), %rax
movq %rax, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
movb $0x0, 0x58(%rdi)
movb $0x1, 0x14(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
addq $0x8, %rsi
leaq 0x14320(%rip), %rdx     # 0x25372
leaq 0x8(%rsp), %rdi
callq 0x125c2
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6390
movq %r12, %rdi
callq 0x65c8
movq 0x50(%rbx), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
callq 0x62f0
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6390
movq %r12, %rdi
callq 0x65c8
movl $0x7, 0x10(%rbx)
movq %r14, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x62e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x110cc
movq %rax, %r14
movq %r15, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x125fa
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %r14
leaq 0x30(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
leaq 0x26101(%rip), %rax     # 0x37220
movq %rax, (%rdi)
leaq 0x48(%rdi), %r15
leaq 0x58(%rdi), %rax
movq %rax, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
movb $0x0, 0x58(%rdi)
movb $0x1, 0x14(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
leaq 0x8(%rsi), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6170
movl 0x28(%r14), %eax
movl %eax, 0x10(%rbx)
movq %r12, %rdi
callq 0x65c8
pushq $0x30
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x62e0
movq %rax, %r14
movq %r15, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x125fa
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x14(%rdi)
addq $0x8, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x63e0
movq 0x8(%r15), %rcx
addq $-0x2, %rcx
movq %rsp, %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
callq 0x62f0
addq $0x48, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x65b0
movq %rsp, %rdi
callq 0x65c8
testq %rbx, %rbx
je 0x111f0
movq %rbx, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x62e0
leaq 0x20(%rsp), %rdi
callq 0x65c8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x65c8
jmp 0x1121f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
leaq 0x25ffe(%rip), %rax     # 0x37268
movq %rax, (%rdi)
leaq 0x48(%rdi), %r15
leaq 0x58(%rdi), %rax
movq %rax, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
xorl %eax, %eax
movb %al, 0x58(%rdi)
andl $0x0, 0x10(%rdi)
movb %al, 0x14(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
addq $0x8, %rsi
movq %rsp, %rdi
callq 0x63e0
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x6390
movq %r14, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x62e0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x65c8
movq %r14, %rdi
callq 0x125fa
movq %rbx, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movq %rdx, %r14
leaq 0x30(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
leaq 0x25fea(%rip), %rax     # 0x373c8
movq %rax, (%rdi)
leaq 0x60(%rdi), %rax
movq %rax, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
leaq 0x50(%rdi), %r15
xorl %eax, %eax
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 0x6170
movq %r14, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x62e0
movq %rax, %r14
movq %r15, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x125fa
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rax
movq %rsi, (%rsp)
addq $0x10, %rdi
movq 0x10(%rax), %rcx
cmpq 0x18(%rax), %rcx
jne 0x114b8
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rsp, %rsi
callq 0x1261e
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movq %rdx, %r14
leaq 0x30(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
movq %rsi, %r15
leaq 0x25fa7(%rip), %rax     # 0x374a8
movq %rax, (%rdi)
leaq 0x60(%rdi), %rax
movq %rax, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
leaq 0x50(%rdi), %r12
xorl %eax, %eax
movb %al, 0x60(%rdi)
movb %al, 0x14(%rdi)
movb $0x1, 0x78(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
addq $0x8, %rsi
movq %rsp, %rdi
callq 0x63e0
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x6390
movq %r13, %rdi
callq 0x65c8
movq %r15, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x62e0
movq %r14, 0x80(%rbx)
movl $0x1, 0x48(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x125fa
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_variable_declaration::AST_variable_declaration(int, tokenId*, AST_expression*, bool)
AST_variable_declaration::AST_variable_declaration(TYPE t, tokenId* id,
                                                   AST_expression* v,
                                                   bool constant
                                                  )
{
    line = id->line;
    column = id->column;

    sym = new symbol(string(id->ident), constant, t, id->line,
                     id->column, 0 != v
                    );
    
    delete id;
    
    value = v;
    has_return = NO;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1263c
leaq 0x25f36(%rip), %rax     # 0x37538
movq %rax, (%rbx)
movq (%r15), %rax
movq %rax, 0x8(%rbx)
pushq $0x78
popq %rdi
callq 0x62d0
movq %rax, %r12
leaq 0x8(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x63e0
movl (%r15), %r8d
movl 0x4(%r15), %r9d
xorl %eax, %eax
testq %r14, %r14
setne %al
movl %eax, (%rsp)
movzbl %r13b, %edx
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movl %ebp, %ecx
callq 0x13e68
movq %r12, 0x98(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq %r15, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x62e0
movq %r14, 0xa0(%rbx)
movl $0x1, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x65c8
jmp 0x1169d
movq %rax, %r14
pushq $0x78
popq %rsi
movq %r12, %rdi
callq 0x62e0
jmp 0x116ad
movq %rax, %r14
movq %rbx, %rdi
callq 0x1266c
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_block::AST_block(int, int)
AST_block::AST_block(int l, int c){
    line = l;
    column = c;
    statements.clear();
    has_return = NO;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x1268c
leaq 0x25e8b(%rip), %rax     # 0x37560
movq %rax, (%r14)
xorps %xmm0, %xmm0
andq $0x0, 0x90(%r14)
movups %xmm0, 0x80(%r14)
movl %ebp, 0x8(%r14)
movl %ebx, 0xc(%r14)
movl $0x1, 0x78(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_block::add_statement(AST_statement*)
void AST_block::add_statement(AST_statement* s){

    if ( statements.size() != 0 ){
        if ( statements.back()->has_return == YES ){
            if (    ( statements.size() > 1 
                      && statements[statements.size() - 2]->has_return != YES)
                 || ( statements.size() == 1 )
               )
            {
                logger->buf << "Codigo inalcanzable";
                logger->warning(s->line, s->column);
            }
            s->has_return = YES;
        } else if (    statements.back()->has_return == MAYBE 
                    && s->has_return != YES )
        {
            s->has_return = MAYBE;
        }
    }

    has_return = s->has_return;

    statements.push_back(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, (%rsp)
leaq 0x80(%rdi), %rbx
movq 0x80(%rdi), %rax
movq 0x88(%rdi), %rdx
movq %rdx, %rcx
subq %rax, %rcx
je 0x11792
movq -0x8(%rdx), %rdx
movl 0x10(%rdx), %edx
cmpl $0x2, %edx
je 0x11783
testl %edx, %edx
jne 0x11792
cmpq $0x9, %rcx
jb 0x117b1
movq -0x10(%rax,%rcx), %rax
cmpl $0x0, 0x10(%rax)
je 0x1177c
leaq 0x26ca9(%rip), %r12     # 0x38400
movq (%r12), %rdi
addq $0x48, %rdi
leaq 0x139ce(%rip), %rsi     # 0x25134
callq 0x62b0
movq (%r12), %rdi
movl 0x8(%r15), %esi
movl 0xc(%r15), %edx
callq 0x15fb8
andl $0x0, 0x10(%r15)
jmp 0x11792
cmpl $0x0, 0x10(%r15)
je 0x11792
movl $0x2, 0x10(%r15)
movl 0x10(%r15), %eax
movl %eax, 0x78(%r14)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x126dc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x8, %rcx
je 0x11750
jmp 0x1177c
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_arg_list::add_argument(int, tokenId*, bool)
void AST_arg_list::add_argument( TYPE t, tokenId* id, bool constant ){
    symbol* next_arg = new symbol(id->ident, constant, t,
                                  id->line, id->column, false);
    
    args.push_back( next_arg );
    
    line = args[0]->getLine();
    
    delete id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %r12d
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
pushq $0x78
popq %rdi
callq 0x62d0
movq %rax, %r14
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x63e0
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
andl $0x0, (%rsp)
movzbl %r12b, %edx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %ebp, %ecx
callq 0x13e68
leaq 0x8(%rsp), %rdi
callq 0x65c8
leaq 0x28(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x10(%r15), %rdi
callq 0x126fa
movq 0x10(%r15), %rax
movq (%rax), %rdi
callq 0x13f10
movl %eax, 0x8(%r15)
movq %rbx, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x62e0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x65c8
jmp 0x1187d
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_discrete_arg_list::add_argument(int, tokenId*, int, int, bool)
void AST_discrete_arg_list::add_argument( TYPE t, tokenId* id,
                                          int min_value, int max_value,
                                          bool constant )
{
    symbol* next_arg = new symbol(id->ident, constant, t,
                                  id->line, id->column, false);
    
    args.push_back( next_arg );
    boundaries.push_back( pair<int,int>(min_value, max_value) );
    
    line = args[0]->getLine();
    
    delete id;
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movl %r8d, 0x14(%rsp)
movl %ecx, %r12d
movq %rdx, %rbx
movl %esi, %r13d
movq %rdi, %r14
pushq $0x78
popq %rdi
callq 0x62d0
movq %rax, %r15
leaq 0x8(%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0x63e0
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
andl $0x0, (%rsp)
movzbl %bpl, %edx
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
movl %r13d, %ecx
callq 0x13e68
leaq 0x18(%rsp), %rdi
callq 0x65c8
leaq 0x38(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x10(%r14), %rdi
callq 0x126fa
leaq 0x28(%r14), %rdi
leaq 0x40(%rsp), %rsi
movl %r12d, (%rsi)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsi)
callq 0x13926
movq 0x10(%r14), %rax
movq (%rax), %rdi
callq 0x13f10
movl %eax, 0x8(%r14)
movq %rbx, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x62e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x65c8
jmp 0x11981
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r15, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_assignment::AST_assignment(AST_lval*, AST_expression*)
AST_assignment::AST_assignment(AST_lval* l, AST_expression* e){

    lvalue = l;
    line = l->line;
    column = l->column;
    
    expr = e;
    has_return = NO;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1268c
leaq 0x25a08(%rip), %rax     # 0x37628
movq %rax, (%r15)
movq %r14, 0x78(%r15)
movq 0x8(%r14), %rax
movq %rax, 0x8(%r15)
movq %rbx, 0x80(%r15)
movl $0x1, 0x10(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_procedure_call::AST_procedure_call(tokenId*, AST_parameters_list*)
AST_procedure_call::AST_procedure_call(tokenId* tk, AST_parameters_list* p){
    funcall = new AST_function_call(tk, p);
    funcall->returns_value = false;
    line = funcall->line;
    column = funcall->column;
    has_return = NO;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x1268c
leaq 0x259ef(%rip), %rax     # 0x37650
movq %rax, (%rbx)
movl $0x88, %edi
callq 0x62d0
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x114c2
movq %r14, 0x78(%rbx)
movb $0x0, 0x78(%r14)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x88, %esi
movq %r14, %rdi
callq 0x62e0
jmp 0x11cb8
movq %rax, %r15
movq %rbx, %rdi
callq 0x12736
movq %r15, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_return::AST_return(token*, AST_expression*)
AST_return::AST_return(token* tk, AST_expression* e){

    line = tk->line;
    column = tk->column;
    delete tk;

    expr = e;
    has_return = YES;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1268c
leaq 0x25996(%rip), %rax     # 0x37678
movq %rax, (%r15)
movq (%r14), %rax
movq %rax, 0x8(%r15)
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x62e0
movq %rbx, 0x78(%r15)
andl $0x0, 0x10(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_conditional::AST_conditional(token*, AST_expression*, AST_block*, AST_conditional*)
AST_conditional::AST_conditional(token* tk, AST_expression* e, AST_block* b,
                                 AST_conditional* branches)
{
    line = tk->line;
    column = tk->column;
    delete tk;

    expr = e;
    blck = b;
    else_if = branches;
    
    has_return = b->has_return;
    
    if ( branches ){
        if ( has_return == YES ){
            if ( branches->has_return == NO ){
                has_return = MAYBE;
            } else {
                has_return = branches->has_return;
            }
        } else if ( has_return == NO ){
            if ( branches->has_return != NO ){
                has_return = MAYBE;
            }
        } else {
            has_return = MAYBE;
        }
    } else if ( !e ) {
        has_return = b->has_return;
    } else if ( b->has_return != NO ){
        has_return = MAYBE;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
callq 0x1268c
leaq 0x25976(%rip), %rax     # 0x376a0
movq %rax, (%rbx)
movq (%r13), %rax
movq %rax, 0x8(%rbx)
pushq $0x8
popq %rsi
movq %r13, %rdi
callq 0x62e0
movq %r15, 0x78(%rbx)
movq %r12, 0x80(%rbx)
movq %r14, 0x88(%rbx)
movl 0x78(%r12), %ecx
movl %ecx, 0x10(%rbx)
testq %r14, %r14
je 0x11d77
pushq $0x2
popq %rax
cmpl $0x1, %ecx
je 0x11d8c
testl %ecx, %ecx
jne 0x11d93
movl 0x10(%r14), %ecx
cmpl $0x1, %ecx
cmovnel %ecx, %eax
jmp 0x11d93
testq %r15, %r15
sete %al
cmpl $0x1, %ecx
sete %cl
orb %al, %cl
jne 0x11d96
pushq $0x2
popq %rax
jmp 0x11d93
cmpl $0x1, 0x10(%r14)
je 0x11d96
movl %eax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_loop::AST_loop(token*, AST_expression*, AST_block*)
AST_loop::AST_loop(token* tk, AST_expression* e, AST_block* b)
{
    line = tk->line;
    column = tk->column;
    delete tk;

    expr = e;
    blck = b;
    
    if ( blck->has_return != NO ){
        has_return = MAYBE;
    } else {
        has_return = NO;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1268c
leaq 0x25910(%rip), %rax     # 0x376d0
movq %rax, (%r12)
movq (%r15), %rax
movq %rax, 0x8(%r12)
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x62e0
movq %r14, 0x78(%r12)
movq %rbx, 0x80(%r12)
xorl %eax, %eax
cmpl $0x1, 0x78(%rbx)
setne %al
incl %eax
movl %eax, 0x10(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_bounded_loop::AST_bounded_loop(token*, tokenId*, AST_expression*, AST_expression*, AST_block*)
AST_bounded_loop::AST_bounded_loop(token* for_, tokenId* id,
                                   AST_expression* l,
                                   AST_expression* r,
                                   AST_block* b)
{
    line = for_->line;
    column = for_->column;
    delete for_;

    name = string(id->ident);
    line_name = id->line;
    column_name = id->column;
    delete id;
    
    left_bound = l;
    right_bound = r;
    
    sym = 0;
    blck = b;
    
    if ( blck->has_return != NO ){
        has_return = MAYBE;
    } else {
        has_return = NO;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1268c
leaq 0x258cb(%rip), %rax     # 0x376f8
movq %rax, (%rbx)
leaq 0x88(%rbx), %rax
movq %rax, 0x78(%rbx)
andq $0x0, 0x80(%rbx)
leaq 0x78(%rbx), %rbp
movb $0x0, 0x88(%rbx)
movq (%r15), %rax
movq %rax, 0x8(%rbx)
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x62e0
leaq 0x8(%r13), %rsi
leaq 0x8(%rsp), %rdi
callq 0x63e0
leaq 0x8(%rsp), %r15
movq %rbp, %rdi
movq %r15, %rsi
callq 0x6390
movq %r15, %rdi
callq 0x65c8
movq (%r13), %rax
movq %rax, 0xa0(%rbx)
movq %r13, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %r13, %rdi
callq 0x62e0
movq %r12, 0xa8(%rbx)
movq (%rsp), %rax
movq %rax, 0xb0(%rbx)
andq $0x0, 0x98(%rbx)
movq %r14, 0xb8(%rbx)
xorl %eax, %eax
cmpl $0x1, 0x78(%r14)
setne %al
incl %eax
movl %eax, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbp, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x12736
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_break::AST_break(token*)
AST_break::AST_break(token* t){
    line = t->line;
    column = t->column;
    delete t;
    
    has_return = NO;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1268c
leaq 0x2580c(%rip), %rax     # 0x37720
movq %rax, (%r14)
movq (%rbx), %rax
movq %rax, 0x8(%r14)
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x62e0
movl $0x1, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_continue::AST_continue(token*)
AST_continue::AST_continue(token* t){
    line = t->line;
    column = t->column;
    delete t;
    
    has_return = NO;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1268c
leaq 0x257f8(%rip), %rax     # 0x37748
movq %rax, (%r14)
movq (%rbx), %rax
movq %rax, 0x8(%r14)
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x62e0
movl $0x1, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_read::AST_read(tokenId*)
AST_read::AST_read(tokenId* t){
    line = t->line;
    column = t->line;
    
    variable = string(t->ident);
    delete t;
    
    has_return = NO;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1268c
leaq 0x257dd(%rip), %rax     # 0x37770
movq %rax, (%rbx)
leaq 0x78(%rbx), %r15
leaq 0x88(%rbx), %rax
movq %rax, 0x78(%rbx)
andq $0x0, 0x80(%rbx)
movb $0x0, 0x88(%rbx)
movl (%r14), %eax
movl %eax, 0x8(%rbx)
movl %eax, 0xc(%rbx)
leaq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x63e0
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6390
movq %r12, %rdi
callq 0x65c8
movq %r14, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x62e0
movl $0x1, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x12736
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_print::add_argument(AST_expression*)
void AST_print::add_argument(AST_expression* e){
    list.push_back(e);
    
    if ( list.size() == 1 ){
        line   = e->line;
        column = e->column;
    }
    has_return = NO;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
addq $0x78, %rdi
movq %rax, %rsi
callq 0x1261e
movq 0x80(%rbx), %rax
subq 0x78(%rbx), %rax
cmpq $0x8, %rax
jne 0x1208a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_fill::AST_fill(AST_expression*, tokenId*)
AST_fill::AST_fill(AST_expression* e, tokenId* f){
    line = e->line;
    column = e->line;
    
    expr = e;
    function = string(f->ident);
    sym = 0;
    delete f;
    
    has_return = NO;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq 0x1268c
leaq 0x25708(%rip), %rax     # 0x377c0
movq %rax, (%rbx)
leaq 0x90(%rbx), %rax
movq %rax, 0x80(%rbx)
andq $0x0, 0x88(%rbx)
leaq 0x80(%rbx), %r15
movb $0x0, 0x90(%rbx)
movl 0x8(%r12), %eax
movl %eax, 0x8(%rbx)
movl %eax, 0xc(%rbx)
movq %r12, 0x78(%rbx)
leaq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x63e0
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6390
movq %r12, %rdi
callq 0x65c8
andq $0x0, 0xa0(%rbx)
testq %r14, %r14
je 0x12129
movq %r14, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x62e0
movl $0x1, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x12736
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_map::AST_map(AST_expression*, AST_expression*, tokenId*)
AST_map::AST_map(AST_expression* s, AST_expression* d, tokenId* f){
    line = s->line;
    column = s->line;
    
    src = s;
    dst = d;
    
    function = string(f->ident);
    sym = 0;
    delete f;
    
    has_return = NO;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x1268c
leaq 0x25661(%rip), %rax     # 0x377e8
movq %rax, (%rbx)
leaq 0x98(%rbx), %rax
movq %rax, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
leaq 0x88(%rbx), %r15
movb $0x0, 0x98(%rbx)
movl 0x8(%r13), %eax
movl %eax, 0x8(%rbx)
movl %eax, 0xc(%rbx)
movq %r13, 0x78(%rbx)
movq %r12, 0x80(%rbx)
leaq 0x8(%r14), %rsi
movq %rsp, %rdi
callq 0x63e0
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6390
movq %r12, %rdi
callq 0x65c8
andq $0x0, 0xa8(%rbx)
testq %r14, %r14
je 0x121fa
movq %r14, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x62e0
movl $0x1, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x12736
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/utils.cpp
// Function: lcm(int, int)
int lcm(int a, int b){
    if ( a == 0 && b == 0 ){
        return 1; // lcm se utiliza para obtener la alineacion comun de un
                  // conjunto de datos, si todos tienen tamaño cero la
                  // alineacion es de cualquier byte
    }
    return abs((double)a*b)/gcd(a,b);
}

// Assembly:
movl %esi, %ecx
orl %edi, %ecx
je 0x13dd6
movl %edi, %eax
cvtsi2sd %edi, %xmm1
cvtsi2sd %esi, %xmm0
mulsd %xmm1, %xmm0
testl %esi, %esi
je 0x13dc1
cltd
idivl %esi
movl %esi, %eax
movl %edx, %esi
jmp 0x13db4
andpd 0x11447(%rip), %xmm0    # 0x25210
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/utils.cpp
// Function: itoa_(int)
char* itoa_(int i){
    char* s = new char[12];
    int k = 12;
    s[--k] = 0;
    while (i > 0) {
        s[--k] = '0' + (i % 10);
        i /= 10;
    }
    if (0 < k) {
        for (int i = 0; i + k < 12; ++ i) {
            s[i] = s[i + k];
        }
    }
    return s;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0xc
popq %rdi
callq 0x6030
movq %rax, %rsi
movq %rax, %rcx
movb $0x0, 0xb(%rax)
pushq $0xb
popq %r8
pushq $0x1
popq %rdi
pushq $0xa
popq %r9
testl %ebx, %ebx
jle 0x13e16
movl %ebx, %eax
xorl %edx, %edx
divl %r9d
orb $0x30, %dl
movb %dl, -0x1(%rcx,%r8)
decq %r8
incl %edi
movl %eax, %ebx
jmp 0x13dfa
testq %r8, %r8
jle 0x13e37
movl %r8d, %eax
addq %rax, %rsi
movl %edi, %eax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x13e37
movb (%rsi,%rdx), %dil
movb %dil, (%rcx,%rdx)
incq %rdx
jmp 0x13e25
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/symbol.cpp
// Function: symbol::symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, int, int, int, bool)
symbol::symbol(string name, bool constant, TYPE type, int line,
               int column, bool initialized)
{
    //al construir se puede validar que no sea NONE!
    this->name = name;
    this->constant = constant;
    this->type = type;
    this->line = line;
    this->column = column;
    this->initialized = initialized;
    this->is_function = false;
    
    this->width = 0;
    this->alignment = 1;
    this->offset = 0;
    this->index = -1;
    
    this->unused = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x50(%rdi), %rax
andl $0x0, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movq %rax, 0x68(%rdi)
andq $0x0, 0x70(%rdi)
callq 0x6170
movb 0x30(%rsp), %al
movb %r12b, 0x20(%rbx)
movl %r15d, 0x24(%rbx)
movl %r14d, 0x28(%rbx)
movl %ebp, 0x2c(%rbx)
movb %al, 0x30(%rbx)
movw $0x100, 0x31(%rbx)      # imm = 0x100
movaps 0x1134f(%rip), %xmm0    # 0x25220
movups %xmm0, 0x34(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x48(%rbx), %rdi
callq 0x140b6
movq %rbx, %rdi
callq 0x65c8
movq %r14, %rdi
callq 0x6530