LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_address::gen_tac_lval(Tac*, int*)
opd *AST_address::gen_tac_lval(Tac* t, int *sta_base){
    opd *o = value->gen_tac_lval(t, sta_base), *r = new opd();
    o = gen_tac_lval_disp(t, o, sta_base);
    t->append_quad(inst::REF, r, o, 0, "referenciar un lvalue");
    return r;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, 0x68(%rsp)
movl $0x18, %edi
callq 0x6390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
callq 0x37ff0
jmp 0x168a9
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x78(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x16440
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x66c0
movq 0x18(%rsp), %rdx
leaq 0x3cc67(%rip), %rsi     # 0x5356b
leaq 0x30(%rsp), %rdi
callq 0x7500
jmp 0x16910
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movl $0x3, %esi
leaq 0x30(%rsp), %r9
callq 0x4de80
jmp 0x16934
leaq 0x30(%rsp), %rdi
callq 0x6778
leaq 0x2f(%rsp), %rdi
callq 0x6400
movq 0x60(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x18, %esi
callq 0x63a0
jmp 0x169a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1699c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6778
leaq 0x2f(%rsp), %rdi
callq 0x6400
movq 0x58(%rsp), %rdi
callq 0x66b0
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rax), %rdi
movq 0xb8(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0xb0(%rsp)
movq 0x48(%rax), %rax
cmpl $0x6, 0x10(%rax)
jne 0x180c6
movq 0x40(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x20(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x4dfb0
movq 0x20(%rsp), %rdi
movl %eax, 0xac(%rsp)
leaq 0xac(%rsp), %rsi
callq 0x20950
movq 0xb8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x66c0
movq 0x38(%rsp), %rdx
leaq 0x3b9af(%rip), %rsi     # 0x5391f
leaq 0x88(%rsp), %rdi
callq 0x7500
jmp 0x17f7f
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movl $0x17, %esi
leaq 0x88(%rsp), %r9
movq %r8, %rcx
callq 0x4de80
jmp 0x17fa5
leaq 0x88(%rsp), %rdi
callq 0x6778
leaq 0x87(%rsp), %rdi
callq 0x6400
movq 0x40(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x4dfb0
movq 0x8(%rsp), %rdi
movl %eax, 0x70(%rsp)
leaq 0x70(%rsp), %rsi
callq 0x20950
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x66c0
movq 0x18(%rsp), %rdx
leaq 0x3b930(%rip), %rsi     # 0x53945
leaq 0x50(%rsp), %rdi
callq 0x7500
jmp 0x18021
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movl $0x16, %esi
leaq 0x50(%rsp), %r9
movq %r8, %rdx
movq %r8, %rcx
callq 0x4de80
jmp 0x18042
leaq 0x50(%rsp), %rdi
callq 0x6778
leaq 0x4f(%rsp), %rdi
callq 0x6400
jmp 0x180c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x18083
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x6778
leaq 0x87(%rsp), %rdi
callq 0x6400
jmp 0x180d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x180ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x6778
leaq 0x4f(%rsp), %rdi
callq 0x6400
jmp 0x180d6
movq 0xb0(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x66b0
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x80, %rdi
callq 0x1ff70
movl %eax, 0x64(%rsp)
movl $0x0, 0x60(%rsp)
movl 0x60(%rsp), %eax
cmpl 0x64(%rsp), %eax
je 0x19096
cmpl $0x0, 0x60(%rsp)
jbe 0x18f52
movq 0x28(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x80, %rdi
movl 0x60(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x20b00
movq (%rax), %rax
addq $0x18, %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
callq 0x4dfb0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %eax, %edx
callq 0x4dfc0
movq 0x28(%rsp), %rdi
addq $0x80, %rdi
movl 0x60(%rsp), %eax
movl %eax, %esi
callq 0x20b00
movq (%rax), %rdi
movq 0x68(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x28(%rsp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, (%rsp)
addq $0x30, %rdi
callq 0x208a0
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x208d0
movq 0x28(%rsp), %rdi
addq $0x80, %rdi
movl 0x60(%rsp), %eax
movl %eax, %esi
callq 0x20b00
movq (%rsp), %rdi
movq (%rax), %rdx
addq $0x30, %rdx
movq 0x58(%rsp), %rsi
callq 0x20860
movq 0x28(%rsp), %rdi
movq %rdi, %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
addq $0x60, %rdi
callq 0x208a0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x208d0
movq 0x28(%rsp), %rdi
addq $0x80, %rdi
movl 0x60(%rsp), %eax
movl %eax, %esi
callq 0x20b00
movq 0x8(%rsp), %rdi
movq (%rax), %rdx
addq $0x60, %rdx
movq 0x48(%rsp), %rsi
callq 0x20860
movq 0x28(%rsp), %rdi
movq %rdi, %rax
addq $0x48, %rax
movq %rax, 0x10(%rsp)
addq $0x48, %rdi
callq 0x208a0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x208d0
movq 0x28(%rsp), %rdi
addq $0x80, %rdi
movl 0x60(%rsp), %eax
movl %eax, %esi
callq 0x20b00
movq 0x10(%rsp), %rdi
movq (%rax), %rdx
addq $0x48, %rdx
movq 0x38(%rsp), %rsi
callq 0x20860
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x18ef0
cmpl $0x0, 0x64(%rsp)
jbe 0x190c3
movq 0x28(%rsp), %rdi
addq $0x80, %rdi
callq 0x1ff90
movq 0x28(%rsp), %rdi
movq (%rax), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x208f0
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x18, %rdi
callq 0x20ad0
movq 0x88(%rsp), %rdi
callq 0x4dfb0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x84(%rsp)
movq 0x78(%rax), %rdi
movq 0x88(%rsp), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0x20(%rsp), %rax
movq 0x88(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x78(%rax), %rax
addq $0x18, %rax
movq %rax, 0x18(%rsp)
callq 0x4dfb0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl %eax, %edx
callq 0x4dfc0
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x88(%rsp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq 0x20(%rsp), %rax
movq 0x88(%rsp), %rdi
movq 0x80(%rax), %rsi
addq $0x30, %rsi
movl 0x84(%rsp), %edx
callq 0x4dfc0
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x18, %edi
callq 0x6390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movl 0x84(%rsp), %esi
movl $0x6, %edx
callq 0x38010
jmp 0x1ba38
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x66c0
movq 0x8(%rsp), %rdx
leaq 0x3834b(%rip), %rsi     # 0x53d9e
leaq 0x50(%rsp), %rdi
callq 0x7500
jmp 0x1ba5f
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x16, %esi
leaq 0x50(%rsp), %r9
movq %rcx, %rdx
callq 0x4de80
jmp 0x1ba81
leaq 0x50(%rsp), %rdi
callq 0x6778
leaq 0x4f(%rsp), %rdi
callq 0x6400
movq 0x20(%rsp), %rdi
movq 0x78(%rdi), %rsi
addq $0x30, %rsi
addq $0x18, %rdi
callq 0x208f0
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, (%rsp)
addq $0x18, %rdi
callq 0x208a0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x208d0
movq 0x20(%rsp), %rax
movq (%rsp), %rdi
movq 0x80(%rax), %rdx
addq $0x48, %rdx
movq 0x40(%rsp), %rsi
callq 0x20860
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
movl $0x18, %esi
callq 0x63a0
jmp 0x1bb4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x1bb45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x6778
leaq 0x4f(%rsp), %rdi
callq 0x6400
movq 0x78(%rsp), %rdi
callq 0x66b0
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20ec0
movq 0x8(%rsp), %rax
leaq 0x4f7fa(%rip), %rcx     # 0x6d088
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x14(%rax)
movl $0x0, 0x10(%rax)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
leaq 0x3a3ee(%rip), %rsi     # 0x57c9e
callq 0x6110
cmpl $0x0, %eax
jne 0x1d8c8
movq 0x8(%rsp), %rax
movl $0x1, 0x48(%rax)
jmp 0x1d935
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
leaq 0x36e2d(%rip), %rsi     # 0x54705
callq 0x6110
cmpl $0x0, %eax
jne 0x1d8f0
movq 0x8(%rsp), %rax
movl $0x0, 0x48(%rax)
jmp 0x1d933
movl $0x8, %edi
callq 0x61b0
movq %rax, %rdi
leaq 0x367cf(%rip), %rax     # 0x540d3
movq %rax, (%rdi)
movq 0x50692(%rip), %rsi     # 0x6dfa0
xorl %eax, %eax
movl %eax, %edx
callq 0x6670
jmp 0x1d992
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x20f40
jmp 0x1d988
jmp 0x1d935
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1d975
movq (%rsp), %rdi
callq 0x20f10
movq (%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x50(%rax)
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20ec0
movq 0x8(%rsp), %rax
leaq 0x4f707(%rip), %rcx     # 0x6d0d0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x3, 0x10(%rax)
movb $0x1, 0x14(%rax)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x48(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1da1a
movq 0x10(%rsp), %rdi
movl $0xc, %esi
callq 0x63a0
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20ec0
movq 0x8(%rsp), %rax
leaq 0x4f6cf(%rip), %rcx     # 0x6d118
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x4, 0x10(%rax)
movb $0x1, 0x14(%rax)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rcx
movss 0x8(%rcx), %xmm0
movss %xmm0, 0x48(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1da9e
movq 0x10(%rsp), %rdi
movl $0xc, %esi
callq 0x63a0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20ec0
movq 0x8(%rsp), %rax
leaq 0x4f687(%rip), %rcx     # 0x6d160
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x6, 0x10(%rax)
movb $0x1, 0x14(%rax)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rcx
movb 0x8(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x48(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1db2d
movq 0x10(%rsp), %rdi
movl $0xc, %esi
callq 0x63a0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x20ec0
movq 0x20(%rsp), %rdi
leaq 0x4f646(%rip), %rax     # 0x6d1b8
movq %rax, (%rdi)
addq $0x48, %rdi
movq %rdi, 0x18(%rsp)
callq 0x6560
movq 0x20(%rsp), %rax
movl $0x5, 0x10(%rax)
movb $0x1, 0x14(%rax)
movq 0x78(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x78(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x78(%rsp), %rsi
addq $0x8, %rsi
leaq 0x3679a(%rip), %rdx     # 0x54352
leaq 0x58(%rsp), %rdi
callq 0x20f80
jmp 0x1dbc4
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x10(%rsp)
leaq 0x58(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x64c0
movq 0x8(%rsp), %rdi
callq 0x6778
movq 0x10(%rsp), %rdi
callq 0x65c0
movq 0x10(%rsp), %rsi
movq %rax, %rcx
addq $-0x2, %rcx
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x63b0
jmp 0x1dc12
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
leaq 0x28(%rsp), %rsi
callq 0x64c0
leaq 0x28(%rsp), %rdi
callq 0x6778
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1dc55
movq (%rsp), %rdi
callq 0x20f10
movq (%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
addq $0x88, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x6778
movq 0x20(%rsp), %rdi
callq 0x20f40
movq 0x50(%rsp), %rdi
callq 0x66b0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x20ec0
movq 0x20(%rsp), %rdi
leaq 0x4f53e(%rip), %rax     # 0x6d200
movq %rax, (%rdi)
addq $0x48, %rdi
movq %rdi, 0x18(%rsp)
callq 0x6560
movq 0x20(%rsp), %rax
movb $0x1, 0x14(%rax)
movq 0x78(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x78(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x78(%rsp), %rsi
addq $0x8, %rsi
leaq 0x36651(%rip), %rdx     # 0x54352
leaq 0x58(%rsp), %rdi
callq 0x20f80
jmp 0x1dd0d
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x10(%rsp)
leaq 0x58(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x64c0
movq 0x8(%rsp), %rdi
callq 0x6778
movq 0x10(%rsp), %rdi
callq 0x65c0
movq 0x10(%rsp), %rsi
movq %rax, %rcx
addq $-0x2, %rcx
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x63b0
jmp 0x1dd5b
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
leaq 0x28(%rsp), %rsi
callq 0x64c0
leaq 0x28(%rsp), %rdi
callq 0x6778
movq 0x20(%rsp), %rax
movl $0x7, 0x10(%rax)
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1ddaa
movq (%rsp), %rdi
callq 0x20f10
movq (%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
addq $0x88, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x6778
movq 0x20(%rsp), %rdi
callq 0x20f40
movq 0x50(%rsp), %rdi
callq 0x66b0
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20ec0
movq 0x8(%rsp), %rdi
leaq 0x4f447(%rip), %rax     # 0x6d250
movq %rax, (%rdi)
addq $0x48, %rdi
movq %rdi, 0x10(%rsp)
callq 0x6560
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movb $0x1, 0x14(%rax)
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
callq 0x6060
jmp 0x1de4d
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1de83
movq (%rsp), %rdi
callq 0x21010
movq (%rsp), %rdi
movl $0x30, %esi
callq 0x63a0
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x6778
movq 0x8(%rsp), %rdi
callq 0x20f40
movq 0x20(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x1, 0x14(%rax)
movq 0x68(%rsp), %rsi
addq $0x8, %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6170
movq 0x10(%rsp), %rdi
callq 0x65c0
movq 0x10(%rsp), %rsi
movq %rax, %rcx
addq $-0x2, %rcx
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x63b0
jmp 0x1df1b
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x28(%rsp), %rsi
callq 0x6500
jmp 0x1df30
leaq 0x28(%rsp), %rdi
callq 0x6778
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1df60
movq (%rsp), %rdi
callq 0x20f10
movq (%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
leaq 0x48(%rsp), %rdi
callq 0x6778
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1df97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6778
leaq 0x48(%rsp), %rdi
callq 0x6778
movq 0x20(%rsp), %rdi
callq 0x66b0
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21030
movq 0x10(%rsp), %rdi
leaq 0x4f2bf(%rip), %rax     # 0x6d298
movq %rax, (%rdi)
addq $0x48, %rdi
movq %rdi, 0x8(%rsp)
callq 0x6560
movq 0x10(%rsp), %rax
movl $0x0, 0x10(%rax)
movb $0x0, 0x14(%rax)
movq 0x48(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x48(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdi
callq 0x6170
jmp 0x1e024
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
leaq 0x28(%rsp), %rsi
callq 0x64c0
leaq 0x28(%rsp), %rdi
callq 0x6778
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1e067
movq (%rsp), %rdi
callq 0x20f10
movq (%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
addq $0x58, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x6778
movq 0x10(%rsp), %rdi
callq 0x21060
movq 0x20(%rsp), %rdi
callq 0x66b0
nopl (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_dereference::AST_dereference(AST_lval*)
AST_dereference::AST_dereference(AST_lval* v){
    is_constant = false;
    value = v;
    line = v->line;
    column = v->column;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21030
movq (%rsp), %rax
leaq 0x4f219(%rip), %rcx     # 0x6d2e0
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x14(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_address::AST_address(AST_lval*)
AST_address::AST_address(AST_lval* v){
    is_constant = false;
    value = v;
    line = v->line;
    column = v->column;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21030
movq (%rsp), %rax
leaq 0x4f211(%rip), %rcx     # 0x6d338
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x14(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_array_access::AST_array_access(AST_lval*, AST_expression*)
AST_array_access::AST_array_access(AST_lval* lvalue, AST_expression* ind ){
    is_constant = false;
    value = lvalue;
    line = lvalue->line;
    column = lvalue->column;
    
    index = ind;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x21030
movq 0x8(%rsp), %rax
leaq 0x4f202(%rip), %rcx     # 0x6d390
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x14(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x50(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21030
movq 0x10(%rsp), %rdi
leaq 0x4f1fa(%rip), %rax     # 0x6d3f8
movq %rax, (%rdi)
addq $0x50, %rdi
movq %rdi, 0x18(%rsp)
callq 0x6560
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movb $0x0, 0x14(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x30(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x30(%rsp), %rsi
addq $0x8, %rsi
callq 0x6060
jmp 0x1e24b
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1e274
movq 0x8(%rsp), %rdi
callq 0x20f10
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x6778
movq 0x10(%rsp), %rdi
callq 0x21060
movq 0x28(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_rlval::AST_rlval(AST_lval*)
AST_rlval::AST_rlval( AST_lval* lvalue ){
    is_constant = false;
    value = lvalue;
    line = lvalue->line;
    column = lvalue->column;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21030
movq (%rsp), %rax
leaq 0x4f169(%rip), %rcx     # 0x6d440
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x14(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x10, %rdi
callq 0x210c0
testb $0x1, %al
jne 0x1e386
jmp 0x1e3a0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x8(%rsp), %rsi
callq 0x21110
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x20ec0
movq 0x18(%rsp), %rdi
leaq 0x4f0ea(%rip), %rax     # 0x6d4d8
movq %rax, (%rdi)
addq $0x50, %rdi
movq %rdi, 0x10(%rsp)
callq 0x6560
movq 0x18(%rsp), %rax
movb $0x0, 0x14(%rax)
movb $0x1, 0x78(%rax)
movq 0x58(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x58(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x58(%rsp), %rsi
addq $0x8, %rsi
leaq 0x30(%rsp), %rdi
callq 0x6170
jmp 0x1e436
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
leaq 0x30(%rsp), %rsi
callq 0x64c0
leaq 0x30(%rsp), %rdi
callq 0x6778
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1e47c
movq 0x8(%rsp), %rdi
callq 0x20f10
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
movq 0x18(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rcx, 0x80(%rax)
movl $0x1, 0x48(%rax)
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x6778
movq 0x18(%rsp), %rdi
callq 0x20f40
movq 0x28(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_conversion::AST_conversion(int, AST_expression*)
AST_conversion::AST_conversion(TYPE t, AST_expression* e){
    
    line = e->line;
    column = e->column;
    
    this->type = t;
    this->expr = e;
    this->original_type = UNDEFINED;
    
    is_constant = e->is_constant;
    
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20ec0
movq 0x8(%rsp), %rax
leaq 0x4f013(%rip), %rcx     # 0x6d510
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x50(%rax)
movl $0x0, 0x48(%rax)
movq 0x10(%rsp), %rcx
movb 0x14(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x14(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movb %r8b, %al
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
andb $0x1, %al
movb %al, 0x67(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x21180
movq 0x18(%rsp), %rax
leaq 0x4efd4(%rip), %rcx     # 0x6d568
movq %rcx, (%rax)
movq 0x70(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x70(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl $0x78, %edi
callq 0x6390
movq %rax, 0x20(%rsp)
jmp 0x1e5bd
movb $0x1, 0x2f(%rsp)
movq 0x70(%rsp), %rsi
addq $0x8, %rsi
leaq 0x30(%rsp), %rdi
callq 0x6170
jmp 0x1e5d7
movq 0x20(%rsp), %rdi
movl 0x7c(%rsp), %ecx
movq 0x70(%rsp), %rax
movl (%rax), %r8d
movl 0x4(%rax), %r9d
movq 0x68(%rsp), %rax
testq %rax, %rax
setne %al
movzbl 0x67(%rsp), %edx
movzbl %al, %esi
movq %rsp, %rax
movl %esi, (%rax)
andl $0x1, %edx
leaq 0x30(%rsp), %rsi
callq 0x294c0
jmp 0x1e613
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movb $0x0, 0x2f(%rsp)
movq %rcx, 0x98(%rax)
leaq 0x30(%rsp), %rdi
callq 0x6778
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1e65c
movq 0x10(%rsp), %rdi
callq 0x20f10
movq 0x10(%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
movq 0x18(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, 0xa0(%rax)
movl $0x1, 0x10(%rax)
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1e6ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1e6b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6778
testb $0x1, 0x2f(%rsp)
jne 0x1e6bd
jmp 0x1e6cc
movq 0x20(%rsp), %rdi
movl $0x78, %esi
callq 0x63a0
jmp 0x1e6ce
movq 0x18(%rsp), %rdi
callq 0x211c0
movq 0x58(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21200
movq (%rsp), %rdi
leaq 0x4ee66(%rip), %rax     # 0x6d580
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x80, %rdi
callq 0x21270
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rdi)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rdi)
addq $0x80, %rdi
callq 0x21280
movq (%rsp), %rax
movl $0x1, 0x78(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x80, %rdi
callq 0x1ff70
cmpq $0x0, %rax
je 0x1e893
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
callq 0x1ff90
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1e85e
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
callq 0x1ff70
cmpq $0x1, %rax
jbe 0x1e7fc
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, 0x8(%rsp)
addq $0x80, %rdi
callq 0x1ff70
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq $0x2, %rsi
callq 0x20b00
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1e813
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
callq 0x1ff70
cmpq $0x1, %rax
jne 0x1e850
leaq 0x4fcbe(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x358f4(%rip), %rsi     # 0x54120
callq 0x6370
leaq 0x4fca0(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x18(%rsp), %rax
movl 0xc(%rax), %edx
callq 0x2f160
movq 0x18(%rsp), %rax
movl $0x0, 0x10(%rax)
jmp 0x1e891
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
callq 0x1ff90
movq (%rax), %rax
cmpl $0x2, 0x10(%rax)
jne 0x1e88f
movq 0x18(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x1e88f
movq 0x18(%rsp), %rax
movl $0x2, 0x10(%rax)
jmp 0x1e891
jmp 0x1e893
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x78(%rdi)
addq $0x80, %rdi
leaq 0x18(%rsp), %rsi
callq 0x212a0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movb %cl, %al
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x78, %edi
callq 0x6390
movq %rax, 0x18(%rsp)
movb $0x1, 0x23(%rsp)
movq 0x60(%rsp), %rsi
addq $0x8, %rsi
leaq 0x30(%rsp), %rdi
callq 0x6170
jmp 0x1e94d
movq 0x18(%rsp), %rdi
movl 0x6c(%rsp), %ecx
movq 0x60(%rsp), %rax
movl (%rax), %r8d
movl 0x4(%rax), %r9d
movzbl 0x5f(%rsp), %edx
movq %rsp, %rax
movl $0x0, (%rax)
andl $0x1, %edx
leaq 0x30(%rsp), %rsi
callq 0x294c0
jmp 0x1e97f
movb $0x0, 0x23(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6778
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq %rax, 0x50(%rsp)
addq $0x10, %rdi
leaq 0x50(%rsp), %rsi
callq 0x21320
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21390
movq (%rax), %rdi
callq 0x29600
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1e9f8
movq 0x8(%rsp), %rdi
callq 0x20f10
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1ea25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6778
testb $0x1, 0x23(%rsp)
jne 0x1ea2e
jmp 0x1ea3d
movq 0x18(%rsp), %rdi
movl $0x78, %esi
callq 0x63a0
jmp 0x1ea3f
movq 0x28(%rsp), %rdi
callq 0x66b0
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movb %r9b, %al
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq %rdx, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movl %r8d, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x78, %edi
callq 0x6390
movq %rax, 0x28(%rsp)
movb $0x1, 0x3b(%rsp)
movq 0x80(%rsp), %rsi
addq $0x8, %rsi
leaq 0x48(%rsp), %rdi
callq 0x6170
jmp 0x1eaf9
movq 0x28(%rsp), %rdi
movl 0x8c(%rsp), %ecx
movq 0x80(%rsp), %rax
movl (%rax), %r8d
movl 0x4(%rax), %r9d
movzbl 0x77(%rsp), %edx
movq %rsp, %rax
movl $0x0, (%rax)
andl $0x1, %edx
leaq 0x48(%rsp), %rsi
callq 0x294c0
jmp 0x1eb31
movb $0x0, 0x3b(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6778
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x68(%rsp)
addq $0x10, %rdi
leaq 0x68(%rsp), %rsi
callq 0x21320
movq 0x20(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x7c(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x213f0
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x213c0
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21390
movq (%rax), %rdi
callq 0x29600
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1ebde
movq 0x18(%rsp), %rdi
callq 0x20f10
movq 0x18(%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x1ec0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6778
testb $0x1, 0x3b(%rsp)
jne 0x1ec17
jmp 0x1ec26
movq 0x28(%rsp), %rdi
movl $0x78, %esi
callq 0x63a0
jmp 0x1ec28
movq 0x40(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x21200
movq 0x8(%rsp), %rax
leaq 0x4e4aa(%rip), %rcx     # 0x6d648
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x78(%rax)
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x80(%rax)
movl $0x1, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21200
movq (%rsp), %rax
leaq 0x4e474(%rip), %rcx     # 0x6d680
movq %rcx, (%rax)
movl $0x88, %edi
callq 0x6390
movq %rax, 0x8(%rsp)
jmp 0x1f220
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1e3c0
jmp 0x1f236
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x78(%rax)
movq 0x78(%rax), %rcx
movb $0x0, 0x78(%rcx)
movq 0x78(%rax), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x78(%rax), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl $0x1, 0x10(%rax)
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x1f298
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x88, %esi
callq 0x63a0
movq (%rsp), %rdi
callq 0x21540
movq 0x18(%rsp), %rdi
callq 0x66b0
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21200
movq (%rsp), %rax
leaq 0x4e3bc(%rip), %rcx     # 0x6d698
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1f317
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0x63a0
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x78(%rax)
movl $0x0, 0x10(%rax)
addq $0x28, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21200
movq (%rsp), %rax
leaq 0x4e35a(%rip), %rcx     # 0x6d6c0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1f3a1
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0x63a0
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x78(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x80(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x88(%rax)
movq 0x18(%rsp), %rcx
movl 0x78(%rcx), %ecx
movl %ecx, 0x10(%rax)
cmpq $0x0, 0x10(%rsp)
je 0x1f43d
movq (%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1f40c
movq 0x10(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x1f3fb
movq (%rsp), %rax
movl $0x2, 0x10(%rax)
jmp 0x1f40a
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
jmp 0x1f43b
movq (%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x1f42e
movq 0x10(%rsp), %rax
cmpl $0x1, 0x10(%rax)
je 0x1f42c
movq (%rsp), %rax
movl $0x2, 0x10(%rax)
jmp 0x1f439
movq (%rsp), %rax
movl $0x2, 0x10(%rax)
jmp 0x1f43b
jmp 0x1f470
cmpq $0x0, 0x20(%rsp)
jne 0x1f456
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x78(%rcx), %ecx
movl %ecx, 0x10(%rax)
jmp 0x1f46e
movq 0x18(%rsp), %rax
cmpl $0x1, 0x78(%rax)
je 0x1f46c
movq (%rsp), %rax
movl $0x2, 0x10(%rax)
jmp 0x1f46e
jmp 0x1f470
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x21200
movq 0x8(%rsp), %rax
leaq 0x4e23d(%rip), %rcx     # 0x6d6f0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1f4ee
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x63a0
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x78(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x80(%rax)
movq 0x80(%rax), %rax
cmpl $0x1, 0x78(%rax)
je 0x1f523
movq 0x8(%rsp), %rax
movl $0x2, 0x10(%rax)
jmp 0x1f52f
movq 0x8(%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x21200
movq 0x18(%rsp), %rdi
leaq 0x4e192(%rip), %rax     # 0x6d718
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x78, %rdi
movq %rdi, 0x10(%rsp)
callq 0x6560
movq 0x18(%rsp), %rax
movq 0x78(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x78(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x1f5d4
movq 0x20(%rsp), %rdi
movl $0x8, %esi
callq 0x63a0
movq 0x70(%rsp), %rsi
addq $0x8, %rsi
leaq 0x38(%rsp), %rdi
callq 0x6170
jmp 0x1f5e9
movq 0x18(%rsp), %rdi
addq $0x78, %rdi
leaq 0x38(%rsp), %rsi
callq 0x64c0
leaq 0x38(%rsp), %rdi
callq 0x6778
movq 0x18(%rsp), %rax
movq 0x70(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0xa0(%rax)
movq 0x70(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xa4(%rax)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1f64f
movq 0x8(%rsp), %rdi
callq 0x20f10
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
movq 0x18(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, 0xa8(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0xb0(%rax)
movq $0x0, 0x98(%rax)
movq 0x58(%rsp), %rcx
movq %rcx, 0xb8(%rax)
movq 0xb8(%rax), %rax
cmpl $0x1, 0x78(%rax)
je 0x1f6c2
movq 0x18(%rsp), %rax
movl $0x2, 0x10(%rax)
jmp 0x1f6ce
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x6778
movq 0x18(%rsp), %rdi
callq 0x21540
jmp 0x1f6d6
movq 0x18(%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x66b0