LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x62f0
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 0x2e923(%rip), %rcx     # 0x3f410
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 0x62f0
movq %rax, %r12
movl 0x28(%r15), %esi
movq %rax, %rdi
movl $0x2, %edx
callq 0x1d02a
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1da64(%rip), %rsi     # 0x2e595
leaq 0x1da9a(%rip), %rdx     # 0x2e5d2
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
callq 0x7008
movq %r14, %rdi
movl $0x13, %esi
movq %r13, %rdx
movq %r13, %rcx
movq %r12, %r8
movq %rbp, %r9
callq 0x2b238
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x10b75
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x6300
movq (%rbx), %r12
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1da4b(%rip), %rsi     # 0x2e5d3
leaq 0x1da91(%rip), %rdx     # 0x2e620
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x7008
movq %r14, %rdi
movl $0x11, %esi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x2b238
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x10bce
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6300
movq (%rbx), %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x6300
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 0x10c2b
movq 0x28(%rsp), %rsi
jmp 0x10c16
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x10c2b
movq 0x48(%rsp), %rsi
incq %rsi
jmp 0x10c26
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_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 0x11688
leaq 0x18(%r15), %r12
movq %r14, %rdi
callq 0x2b316
movl %eax, %ebp
movl $0x18, %edi
callq 0x62f0
movl %ebp, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x6080
incq 0x28(%r15)
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1d36a(%rip), %rsi     # 0x2e933
leaq 0x1d388(%rip), %rdx     # 0x2e958
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x7008
movq %r14, %rdi
movl $0x17, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x2b238
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1160c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
leaq 0x30(%r15), %r12
movq %r14, %rdi
callq 0x2b316
movl %eax, %ebp
movl $0x18, %edi
callq 0x62f0
movl %ebp, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x6080
incq 0x40(%r15)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1d313(%rip), %rsi     # 0x2e959
leaq 0x1d332(%rip), %rdx     # 0x2e97f
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7008
movq %r14, %rdi
movl $0x16, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x2b238
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11688
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
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 0x116ac
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x116bd
movq (%r13), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_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 0x62f0
movq %rax, %rbx
cmpb $0x1, %bpl
jne 0x11cf9
movq %rbx, %rdi
callq 0x1d014
movl $0x18, %edi
callq 0x62f0
movq %rax, %r15
movq 0x70(%r12), %rsi
movq %rax, %rdi
callq 0x1d00c
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1cdb6(%rip), %rsi     # 0x2ea7b
leaq 0x1cde2(%rip), %rdx     # 0x2eaae
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x7008
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x2b238
movq 0x28(%rsp), %rdi
jmp 0x11d49
movq 0x70(%r12), %rsi
movq %rbx, %rdi
callq 0x1d00c
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1cd65(%rip), %rsi     # 0x2ea7b
leaq 0x1cd91(%rip), %rdx     # 0x2eaae
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7008
movq %r14, %rdi
movl $0x8, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x2b238
movq 0x8(%rsp), %rdi
xorl %ebx, %ebx
cmpq %r13, %rdi
je 0x11d5a
movq (%r13), %rsi
incq %rsi
callq 0x6300
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 0x11db6
movq 0x38(%rsp), %rsi
jmp 0x11d92
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11db6
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x11db1
movq %rax, %r14
movl $0x18, %esi
movq %r15, %rdi
jmp 0x11db1
jmp 0x11da6
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x6300
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_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 0x16888
movq %r15, %rdi
callq 0x2b316
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 0x2b316
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x2b320
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 0x2b320
movl $0x18, %edi
callq 0x62f0
movq %rax, %r12
movq %rax, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0x1d02a
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x1b78b(%rip), %rsi     # 0x2edb2
leaq 0x1b7a0(%rip), %rdx     # 0x2edce
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x7008
movq %r15, %rdi
movl $0x16, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r12, %r8
movq %r13, %r9
callq 0x2b238
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x13669
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq 0x78(%rbx), %rdx
addq $0x30, %rdx
cmpq %rdx, %r14
je 0x13681
movq (%rdx), %rsi
movq %r14, %rdi
callq 0x16cfe
movq 0x80(%rbx), %r15
leaq 0x48(%r15), %rdx
movq 0x48(%r15), %rsi
cmpq %rdx, %rsi
je 0x136ad
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 0x136e3
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x136de
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29814(%rip), %rax     # 0x3e028
movq %rax, (%rdi)
movb $0x0, 0x14(%rdi)
movl $0x0, 0x10(%rdi)
leaq 0x8(%rsi), %r12
leaq 0x1e301(%rip), %rsi     # 0x32b2e
movq %r12, %rdi
callq 0x60d0
testl %eax, %eax
je 0x14871
leaq 0x1aed9(%rip), %rsi     # 0x2f719
movq %r12, %rdi
callq 0x60d0
testl %eax, %eax
je 0x14877
movl $0x8, %edi
callq 0x6150
leaq 0x1a88a(%rip), %rcx     # 0x2f0e7
movq %rcx, (%rax)
movq 0x2a739(%rip), %rsi     # 0x3efa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6530
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 0x148a9
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %r15, %rdi
callq 0x6300
movq %r14, 0x50(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x16940
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2976c(%rip), %rcx     # 0x3e070
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 0x6300
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29760(%rip), %rcx     # 0x3e0b8
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 0x6300
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29750(%rip), %rcx     # 0x3e100
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 0x6300
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29733(%rip), %rcx     # 0x3e148
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 0x16c68
leaq 0x1a91f(%rip), %rsi     # 0x2f382
leaq 0x8(%rsp), %rdi
callq 0x65b0
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63d0
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x14a93
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq 0x50(%rbx), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x6320
leaq 0x8(%rsp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x63d0
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0x14ad2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq $0x0, 0x10(%r14)
movq 0x8(%r14), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x14af9
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %r14, %rdi
callq 0x6300
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14b33
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x14b36
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x14b36
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x14b4a
movq (%r13), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x16940
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/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 0x295f9(%rip), %rcx     # 0x3e190
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 0x16c68
leaq 0x1a7a4(%rip), %rsi     # 0x2f382
leaq 0x8(%rsp), %rdi
callq 0x65b0
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63d0
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x14c0e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq 0x50(%rbx), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x6320
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63d0
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x14c4e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
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 0x14c7c
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %r14, %rdi
callq 0x6300
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14cb6
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x14cb9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x14cb9
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x14ccd
movq (%r13), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x16940
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x294cb(%rip), %rcx     # 0x3e1e0
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 0x14d62
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x30, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6300
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x14d91
movq (%r12), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x16940
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16c68
movq 0x8(%r15), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x6320
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 0x14e24
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x14e4b
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %rbx, %rdi
callq 0x6300
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x14e6f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
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 0x14e9e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x14e9e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x14eb5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.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 0x2932e(%rip), %rcx     # 0x3e228
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 0x16c68
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x63d0
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x14f60
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x14f87
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %rbx, %rdi
callq 0x6300
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x14fb9
movq (%r12), %rsi
incq %rsi
callq 0x6300
movq %r14, %rdi
callq 0x16940
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x292c9(%rip), %rcx     # 0x3e388
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 0x15116
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6300
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x15145
movq (%r12), %rsi
incq %rsi
callq 0x6300
movq %r14, %rdi
callq 0x16940
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x151c8
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
cmpq 0x20(%rdi), %rsi
je 0x151d8
movq %rax, (%rsi)
addq $0x8, 0x18(%rdi)
jmp 0x151e4
addq $0x10, %rdi
movq %rsp, %rdx
callq 0x176b4
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29242(%rip), %rcx     # 0x3e468
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 0x16c68
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x63d0
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x1528e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq $0x0, 0x10(%r15)
movq 0x8(%r15), %rax
movb $0x0, (%rax)
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0x152b5
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %r15, %rdi
callq 0x6300
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 0x152f7
movq (%r13), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x16940
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
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 0x48(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x68(%rdi)
movq %rcx, 0x60(%rdi)
movq %rax, 0x70(%rdi)
leaq 0x88(%rdi), %rcx
movq %rcx, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movb $0x0, 0x88(%rdi)
leaq 0x29128(%rip), %rax     # 0x3e4f8
movq %rax, (%rdi)
movq (%rdx), %rax
movq %rax, 0x8(%rdi)
movl $0x78, %edi
callq 0x62f0
movq %rax, %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x16c68
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 0x17f4a
movq %r12, 0x98(%rbx)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1544d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq $0x0, 0x10(%r15)
movq 0x8(%r15), %rax
movb $0x0, (%rax)
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0x15474
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %r15, %rdi
callq 0x6300
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
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x154c2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x154c2
movq %rax, %r14
movl $0x78, %esi
movq %r12, %rdi
callq 0x6300
jmp 0x154d4
movq %rax, %r14
movq %rbx, %rdi
callq 0x1699c
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq 0x80(%rdi), %rax
movq 0x88(%rdi), %rsi
movq %rsi, %rcx
subq %rax, %rcx
je 0x155ee
movq -0x8(%rsi), %rdx
movl 0x10(%rdx), %edx
cmpl $0x2, %edx
je 0x155df
testl %edx, %edx
jne 0x155ee
cmpq $0x9, %rcx
jb 0x15626
movq -0x10(%rax,%rcx), %rax
cmpl $0x0, 0x10(%rax)
je 0x155d5
leaq 0x29e62(%rip), %r15     # 0x3f408
movq (%r15), %rdi
addq $0x48, %rdi
leaq 0x19b80(%rip), %rsi     # 0x2f134
movl $0x13, %edx
callq 0x6370
movq (%r15), %rdi
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
callq 0x1a874
movq 0x88(%rbx), %rsi
movl $0x0, 0x10(%r14)
jmp 0x155ee
cmpl $0x0, 0x10(%r14)
je 0x155ee
movl $0x2, 0x10(%r14)
movl 0x10(%r14), %eax
movl %eax, 0x78(%rbx)
cmpq 0x90(%rbx), %rsi
je 0x1560b
movq %r14, (%rsi)
addq $0x8, 0x88(%rbx)
jmp 0x1561c
subq $-0x80, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x177f0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x8, %rcx
je 0x1559f
jmp 0x155d5
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movl $0x78, %edi
callq 0x62f0
movq %rax, %r14
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x16c68
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
movl $0x0, (%rsp)
movzbl %r12b, %edx
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
movl %ebp, %ecx
callq 0x17f4a
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x156c8
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6300
movq %r14, 0x10(%rsp)
movq 0x18(%r15), %rsi
cmpq 0x20(%r15), %rsi
je 0x156e1
movq %r14, (%rsi)
addq $0x8, 0x18(%r15)
jmp 0x156ef
leaq 0x10(%r15), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1792c
movq 0x10(%r15), %rax
movq (%rax), %rdi
callq 0x1801e
movl %eax, 0x8(%r15)
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x15726
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %rbx, %rdi
callq 0x6300
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x15761
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x15761
movq %rax, %rbx
movl $0x78, %esi
movq %r14, %rdi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x10(%rsp)
movq %rdx, %rbx
movl %esi, %r13d
movq %rdi, %r14
movl $0x78, %edi
callq 0x62f0
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x16c68
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
movl $0x0, (%rsp)
movzbl %bpl, %edx
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
movl %r13d, %ecx
callq 0x17f4a
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x1581e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6300
movq %r15, 0x18(%rsp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x15837
movq %r15, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x15845
leaq 0x10(%r14), %rdi
leaq 0x18(%rsp), %rdx
callq 0x1792c
leaq 0x28(%r14), %rdi
leaq 0x40(%rsp), %rsi
movl 0x10(%rsp), %eax
movl %eax, (%rsi)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsi)
callq 0x17a68
movq 0x10(%r14), %rax
movq (%rax), %rdi
callq 0x1801e
movl %eax, 0x8(%r14)
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x15897
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %rbx, %rdi
callq 0x6300
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x158d2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x158d2
movq %rax, %rbx
movl $0x78, %esi
movq %r15, %rdi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %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 0x48(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x68(%rdi)
movq %rcx, 0x60(%rdi)
movq %rax, 0x70(%rdi)
leaq 0x288bc(%rip), %rax     # 0x3e610
movq %rax, (%rdi)
movl $0x88, %edi
callq 0x62f0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x151e6
movq %r12, 0x78(%rbx)
movb $0x0, 0x78(%r12)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x88, %esi
movq %r12, %rdi
callq 0x6300
jmp 0x15dad
movq %rax, %r14
movq %rbx, %rdi
callq 0x16a62
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
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 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x28824(%rip), %rcx     # 0x3e638
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x6300
movq %rbx, 0x78(%r14)
movl $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
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 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x287c0(%rip), %rcx     # 0x3e660
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x6300
movq %r15, 0x78(%rbx)
movq %r12, 0x80(%rbx)
movq %r14, 0x88(%rbx)
movl 0x78(%r12), %ecx
movl %ecx, 0x10(%rbx)
testq %r14, %r14
je 0x15ef0
movl $0x2, %eax
cmpl $0x1, %ecx
je 0x15f14
testl %ecx, %ecx
jne 0x15f05
movl 0x10(%r14), %ecx
cmpl $0x1, %ecx
cmovnel %ecx, %eax
jmp 0x15f05
testq %r15, %r15
sete %al
cmpl $0x1, %ecx
sete %cl
orb %al, %cl
movl $0x2, %eax
jne 0x15f08
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x1, 0x10(%r14)
jne 0x15f05
jmp 0x15f08
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
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 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x28718(%rip), %rcx     # 0x3e690
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x6300
movq %r15, 0x78(%rbx)
movq %r14, 0x80(%rbx)
xorl %eax, %eax
cmpl $0x1, 0x78(%r14)
setne %al
incl %eax
movl %eax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movq %r9, %r14
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rax
movq %rdi, %rbx
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 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x2869b(%rip), %rdx     # 0x3e6b8
movq %rdx, (%rdi)
leaq 0x78(%rdi), %rbp
leaq 0x88(%rdi), %r15
movq %r15, 0x78(%rdi)
movq %rcx, 0x80(%rdi)
movb $0x0, 0x88(%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x6300
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x16c68
leaq 0x18(%rsp), %r15
movq %rbp, %rdi
movq %r15, %rsi
callq 0x63d0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x16095
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6300
movq (%r13), %rax
movq %rax, 0xa0(%rbx)
movq $0x0, 0x10(%r13)
movq 0x8(%r13), %rax
movb $0x0, (%rax)
movq 0x8(%r13), %rdi
leaq 0x18(%r13), %rax
cmpq %rax, %rdi
je 0x160c7
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %r13, %rdi
callq 0x6300
movq 0x8(%rsp), %rax
movq %rax, 0xa8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0xb0(%rbx)
movq $0x0, 0x98(%rbx)
movq %r14, 0xb8(%rbx)
xorl %eax, %eax
cmpl $0x1, 0x78(%r14)
setne %al
incl %eax
movl %eax, 0x10(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbp), %rdi
cmpq %r15, %rdi
je 0x16133
movq (%r15), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x16a62
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rsi, %rax
movq %rdi, %rbx
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 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x2854c(%rip), %rcx     # 0x3e6e0
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x6300
movl $0x1, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rsi, %rax
movq %rdi, %rbx
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 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x28504(%rip), %rcx     # 0x3e708
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x6300
movl $0x1, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %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 0x48(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x68(%rdi)
movq %rcx, 0x60(%rdi)
movq %rax, 0x70(%rdi)
leaq 0x284b0(%rip), %rcx     # 0x3e730
movq %rcx, (%rdi)
leaq 0x78(%rdi), %r15
leaq 0x88(%rdi), %r12
movq %r12, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movb $0x0, 0x88(%rdi)
movl (%rsi), %eax
movl %eax, 0x8(%rdi)
movl %eax, 0xc(%rdi)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x16c68
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63d0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x162e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
movq $0x0, 0x10(%r14)
movq 0x8(%r14), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x1630f
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %r14, %rdi
callq 0x6300
movl $0x1, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x16348
movq (%r12), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x16a62
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0x78(%rdi), %r14
movq 0x80(%rdi), %rsi
cmpq 0x88(%rdi), %rsi
je 0x163f3
movq %rax, (%rsi)
movq 0x80(%rbx), %rax
addq $0x8, %rax
movq %rax, 0x80(%rbx)
jmp 0x16405
movq %rsp, %rdx
movq %r14, %rdi
callq 0x176b4
movq 0x80(%rbx), %rax
subq (%r14), %rax
cmpq $0x8, %rax
jne 0x1641a
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop