LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_un_op::fill_and_check(symbol_table*)
void AST_un_op::fill_and_check(symbol_table* st){
    expr->fill_and_check(st);
    
    if ( expr->type == BOOLEAN ){
        if ( oper_type == NOT ){
            type = BOOLEAN;
        } else {
            // Reportar error de argumento booleano y operando menos unario
            logger->buf << "Operando de tipo boolean, esperado float o int.";
            logger->error(line, column);
        }
    } else if ( expr->type == INT || expr->type == FLOAT ){
        
        if ( oper_type == NEG ){
            type = expr->type;
        } else {
            // Reportar error de argumento numero y operando negacion
            logger->buf << "Operando de tipo '" << (expr->type == INT ? "int": "float")
                        << "', esperado boolean.";
            logger->error(line, column);
        }
    } else {
        // Reportar error de tipo de argumento
        logger->buf << "Operando de tipo '" << types.types[expr->type]->name
                    << "', esperado '" << (oper_type == NOT ? "boolean": "float o int")
                    << "'.";
        logger->error(line, column);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rax
movl 0x10(%rax), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0x92be
cmpl $0x0, 0x48(%rbx)
je 0x9366
leaq 0x2f183(%rip), %r14     # 0x38400
movq (%r14), %rdi
addq $0x48, %rdi
leaq 0x1a5b1(%rip), %rsi     # 0x2383c
callq 0x62b0
movq 0x50(%rbx), %rcx
cmpl $0x3, 0x10(%rcx)
leaq 0x1a5e9(%rip), %rcx     # 0x23888
leaq 0x1a5a9(%rip), %rsi     # 0x2384f
cmoveq %rcx, %rsi
movq %rax, %rdi
callq 0x62b0
leaq 0x1a59c(%rip), %rsi     # 0x23855
jmp 0x9349
cmpl $0x6, %eax
jne 0x92d9
cmpl $0x1, 0x48(%rbx)
jne 0x9371
movl $0x6, 0x10(%rbx)
jmp 0x9369
leaq 0x2f120(%rip), %r14     # 0x38400
movq (%r14), %rdi
addq $0x48, %rdi
leaq 0x1a54e(%rip), %rsi     # 0x2383c
callq 0x62b0
movq 0x50(%rbx), %rcx
movslq 0x10(%rcx), %rcx
leaq 0x2f106(%rip), %rdx     # 0x38408
movq (%rdx), %rdx
movq (%rdx,%rcx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x1a54e(%rip), %rsi     # 0x2386a
movq %rax, %rdi
callq 0x62b0
cmpl $0x1, 0x48(%rbx)
leaq 0x1a549(%rip), %rcx     # 0x23878
leaq 0x1a54a(%rip), %rsi     # 0x23880
cmoveq %rcx, %rsi
movq %rax, %rdi
callq 0x62b0
leaq 0x1f24e(%rip), %rsi     # 0x28597
movq %rax, %rdi
callq 0x62b0
movq (%r14), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16112
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2f088(%rip), %r14     # 0x38400
movq (%r14), %rdi
addq $0x48, %rdi
leaq 0x1a486(%rip), %rsi     # 0x2380c
jmp 0x934c
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_enum_constant::fill_and_check(symbol_table*)
void AST_enum_constant::fill_and_check(symbol_table* st){
    for (vector< type_descriptor* >::iterator it = types.types.begin(); it != types.types.end(); ++ it) {
        if (typeid(**it) != typeid(enum_type)) {
            continue;
        }
        set<string> *e = ((enum_type*)(*it))->values;
        enum_index = 0;
        set<string>::iterator ite;
        for (ite = e->begin(); ite != e->end(); ++ ite) {
            if (!value.compare(*ite)) {
                break;
            }
            ++ enum_index;
        }
        if (ite != e->end()) {
            break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2f013(%rip), %r13     # 0x38408
movq (%r13), %rbp
leaq 0x48(%rdi), %r14
cmpq 0x8(%r13), %rbp
je 0x9463
movq (%rbp), %rax
testq %rax, %rax
je 0x9472
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x2e856(%rip), %rsi     # 0x37c70
callq 0x12274
testb %al, %al
je 0x9429
addq $0x8, %rbp
jmp 0x93fd
movq (%rbp), %rax
movq 0x38(%rax), %r15
andl $0x0, 0x68(%rbx)
movq 0x18(%r15), %r12
addq $0x8, %r15
cmpq %r15, %r12
je 0x9423
leaq 0x20(%r12), %rsi
movq %r14, %rdi
callq 0x6040
testl %eax, %eax
je 0x9463
incl 0x68(%rbx)
movq %r12, %rdi
callq 0x6330
movq %rax, %r12
jmp 0x943d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6320
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_ident::check_call(symbol_table*)
void AST_ident::check_call(symbol_table* st){ 
    fill_and_check(st);
    
    sym = st->lookup(value);
    
    /* El simbolo existe en la tabla */
    if ( sym && sym->isConst() ){
        if (    typeid(*types.types[sym->getType()]) == typeid(array_descriptor)
             || typeid(*types.types[sym->getType()]) == typeid(struct_type)
             || typeid(*types.types[sym->getType()]) == typeid(union_type)
        )
        {
            logger->buf << "Pasaje por referencia de constante '"
                        << sym->getName() << "' definida en "
                        << sym->getLine() << ':' << sym->getColumn();
            logger->error(line, column);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
xorl %edx, %edx
callq *0x10(%rax)
leaq 0x48(%rbx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x63e0
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1422e
movq %rax, 0x68(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x65c8
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x985f
callq 0x13f08
testb %al, %al
je 0x985f
movq 0x68(%rbx), %rdi
callq 0x13f0c
cltq
leaq 0x2ecd1(%rip), %r14     # 0x38408
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x986b
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x2d73b(%rip), %rsi     # 0x36e90
callq 0x1227e
testb %al, %al
jne 0x97c6
movq 0x68(%rbx), %rdi
callq 0x13f0c
cltq
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x986b
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x2e4b9(%rip), %rsi     # 0x37c40
callq 0x1227e
testb %al, %al
jne 0x97c6
movq 0x68(%rbx), %rdi
callq 0x13f0c
cltq
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x986b
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x2e49f(%rip), %rsi     # 0x37c58
callq 0x1227e
testb %al, %al
je 0x985f
leaq 0x2ec33(%rip), %r12     # 0x38400
movq (%r12), %rdi
addq $0x48, %rdi
leaq 0x1a140(%rip), %rsi     # 0x2391c
callq 0x62b0
movq %rax, %r14
movq 0x68(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x13efa
movq %r14, %rdi
movq %r15, %rsi
callq 0x62a0
leaq 0x1a0eb(%rip), %rsi     # 0x238f2
movq %rax, %rdi
callq 0x62b0
movq %rax, %r14
movq 0x68(%rbx), %rdi
callq 0x13f10
movq %r14, %rdi
movl %eax, %esi
callq 0x6510
pushq $0x3a
popq %rsi
movq %rax, %rdi
callq 0x6350
movq %rax, %r14
movq 0x68(%rbx), %rdi
callq 0x13f14
movq %r14, %rdi
movl %eax, %esi
callq 0x6510
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq (%r12), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x16112
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x6320
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x9882
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_dereference::fill_and_check(symbol_table*, bool)
void AST_dereference::fill_and_check(symbol_table* st, bool lval){
    value->fill_and_check(st, lval);
    
    type_descriptor* td = types.types[value->type];
    
    if ( typeid(*td) == typeid(pointer_descriptor) ){
        type = ((pointer_descriptor*)td)->base;
    } else {
        type = INVALID;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x48(%rbx), %rax
movslq 0x10(%rax), %rax
leaq 0x2eb58(%rip), %rcx     # 0x38408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x98e7
movq (%r14), %rax
movq -0x8(%rax), %rdi
leaq 0x2d5de(%rip), %rsi     # 0x36ea8
callq 0x1227e
testb %al, %al
je 0x98d9
movl 0x30(%r14), %eax
jmp 0x98dc
pushq $0x1
popq %rax
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x6320
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_address::fill_and_check(symbol_table*, bool)
void AST_address::fill_and_check(symbol_table* st, bool lval){

    value->fill_and_check(st, true);

    if (typeid(value) == typeid(AST_address)) {
        type = INVALID;
    } else {

        pointer_descriptor* pd = new pointer_descriptor( value->type,
                                                         types.types[
                                                             value->type]->name);

        if ( !types.has_type( pd->name ) ){
            type = types.add_type( pd );
        } else {
            type = types.index_of( pd->name );
            delete pd;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
pushq $0x1
popq %rdx
callq *0x10(%rax)
leaq 0x2d5b1(%rip), %rdi     # 0x36ec0
leaq 0x2e20a(%rip), %rsi     # 0x37b20
callq 0x1227e
testb %al, %al
je 0x992c
movl $0x1, 0x10(%r14)
jmp 0x99fb
pushq $0x38
popq %rdi
callq 0x62d0
movq %rax, %rbx
movq 0x48(%r14), %rax
movslq 0x10(%rax), %r15
leaq 0x2eac2(%rip), %rax     # 0x38408
movq (%rax), %rax
movq (%rax,%r15,8), %rsi
addq $0x8, %rsi
movq %rsp, %rdi
callq 0x63e0
movq %rsp, %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x14f58
movq %rsp, %rdi
callq 0x65c8
movq %rbx, %r15
addq $0x8, %r15
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x63e0
leaq 0x2ea7b(%rip), %rdi     # 0x38408
movq %r12, %rsi
callq 0x15840
movl %eax, %ebp
leaq 0x40(%rsp), %rdi
callq 0x65c8
testb %bpl, %bpl
je 0x99e8
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x63e0
leaq 0x2ea4b(%rip), %rdi     # 0x38408
movq %r12, %rsi
callq 0x158b8
movl %eax, 0x10(%r14)
leaq 0x20(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x122a6
pushq $0x38
popq %rsi
movq %rbx, %rdi
callq 0x62e0
jmp 0x99fb
leaq 0x2ea19(%rip), %rdi     # 0x38408
movq %rbx, %rsi
callq 0x157d0
movl %eax, 0x10(%r14)
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x9a1a
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x65c8
jmp 0x9a3c
movq %rax, %r14
movq %rsp, %rdi
callq 0x65c8
jmp 0x9a31
movq %rax, %r14
pushq $0x38
popq %rsi
movq %rbx, %rdi
callq 0x62e0
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_array_access::fill_and_check(symbol_table*, bool)
void AST_array_access::fill_and_check(symbol_table* st, bool lval){
    
    //en caso de haber un error de sintáxis con recuperación de errores puede no haber valor
    if ( !value )
        return;
    
    value->fill_and_check(st, lval);
    
    if ( typeid(*(types.types[ value->type ])) != typeid(array_descriptor) ){
        logger->buf << "Intento de acceso indexado a tipo '"
                    << types.types[value->type]->name << "'.";
        logger->error(line, column);
        type = INVALID;
    } else {
        type = ((array_descriptor*)types.types[ value->type ])->base;
    }
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x9b04
movq (%rdi), %rax
movzbl %dl, %edx
callq *0x10(%rax)
movq 0x48(%rbx), %rax
movslq 0x10(%rax), %rax
leaq 0x2e997(%rip), %r14     # 0x38408
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x9b0a
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x2d401(%rip), %rsi     # 0x36e90
callq 0x12274
testb %al, %al
je 0x9aef
leaq 0x2e961(%rip), %r15     # 0x38400
movq (%r15), %rdi
addq $0x48, %rdi
leaq 0x19e94(%rip), %rsi     # 0x23941
callq 0x62b0
movq 0x48(%rbx), %rcx
movslq 0x10(%rcx), %rcx
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x1eac3(%rip), %rsi     # 0x28597
movq %rax, %rdi
callq 0x62b0
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x16112
pushq $0x1
popq %rax
jmp 0x9b01
movq 0x48(%rbx), %rax
movslq 0x10(%rax), %rax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x6320
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_conversion::fill_and_check(symbol_table*)
void AST_conversion::fill_and_check(symbol_table* st){
    expr->fill_and_check(st);
    original_type = expr->type;
    if (!types.is_base(original_type) || !types.is_base(type) || STRING == original_type || STRING == type) {
        logger->buf << "Conversión permitida sólo entre tipos primitivos ('"
                    << types.types[original_type]->name << "' a '"
                    << types.types[type]->name << "'.";
        logger->error(line, column);
        type = INVALID;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rax
movl 0x10(%rax), %esi
movl %esi, 0x48(%rbx)
leaq 0x2e647(%rip), %r14     # 0x38408
movq %r14, %rdi
callq 0x158ae
testb %al, %al
je 0x9dec
movl 0x10(%rbx), %esi
leaq 0x2e631(%rip), %rdi     # 0x38408
callq 0x158ae
testb %al, %al
je 0x9dec
cmpl $0x7, 0x48(%rbx)
je 0x9dec
cmpl $0x7, 0x10(%rbx)
jne 0x9e67
leaq 0x2e60d(%rip), %r15     # 0x38400
movq (%r15), %rdi
addq $0x48, %rdi
leaq 0x19ba2(%rip), %rsi     # 0x239a3
callq 0x62b0
movslq 0x48(%rbx), %rcx
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x19bb5(%rip), %rsi     # 0x239d9
movq %rax, %rdi
callq 0x62b0
movslq 0x10(%rbx), %rcx
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x1e74d(%rip), %rsi     # 0x28597
movq %rax, %rdi
callq 0x62b0
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x16112
movl $0x1, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_block::fill_and_check(symbol_table*)
void AST_block::fill_and_check(symbol_table* st){
    
    /* Verificar cada statement del bloque, se asume que la tabla de
     * simbolos es nueva o que tiene los argumentos de la funcion en caso
     * de ser el cuerpo de una
     */
    vector<AST_statement*>::iterator it;
    
    for (vector<AST_statement*>::iterator it = statements.begin();
         it != statements.end(); ++ it)
     {
        if ( typeid(**it) == typeid(AST_block) ){
            symbol_table* nested_block = st->new_son();
            (*it)->fill_and_check(nested_block);
            delete nested_block;
        } else {
            (*it)->fill_and_check(st);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %rbp
leaq 0x2d07b(%rip), %r15     # 0x36f08
pushq $0x48
popq %r12
cmpq 0x88(%r14), %rbp
je 0x9efb
movq (%rbp), %rax
testq %rax, %rax
je 0x9f0a
movq (%rax), %rax
movq -0x8(%rax), %rdi
movq %r15, %rsi
callq 0x1227e
testb %al, %al
je 0x9ee8
movq %rbx, %rdi
callq 0x143ac
movq %rax, %r13
movq (%rbp), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0x8(%rax)
testq %r13, %r13
je 0x9edb
movq %r13, %rdi
callq 0x122be
movq %r13, %rdi
movq %r12, %rsi
callq 0x62e0
jmp 0x9ef5
movq (%rbp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
addq $0x8, %rbp
jmp 0x9e91
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6320
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_parameters_list::fill_and_check(symbol_table*, std::vector<bool, std::allocator<bool>>&)
void AST_parameters_list::fill_and_check(symbol_table* st,
                                         vector<bool>& constant)
{
    /* Verifica el tipo de cada uno de los parametros reales de la llamada de
     * una funcion
     */
    for (vector<AST_expression*>::iterator it=elem.begin(); it != elem.end(); ++it){
        if (0 != *it) {
            (*it)->fill_and_check(st);
            (*it)->check_call(st);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
cmpq 0x18(%r14), %r15
je 0x9f48
movq (%r15), %rdi
testq %rdi, %rdi
je 0x9f42
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
addq $0x8, %r15
jmp 0x9f1f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_parameters_list::fill_and_check(symbol_table*)
void AST_parameters_list::fill_and_check(symbol_table* st){
    
    /* Verifica el tipo de cada uno de los parametros reales de la llamada de
     * una funcion
     */
    for (vector<AST_expression*>::iterator it=elem.begin(); it != elem.end(); ++it){
        if (0 != *it) {
            (*it)->fill_and_check(st);
            (*it)->check_call(st);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
cmpq 0x18(%r14), %r15
je 0x9f86
movq (%r15), %rdi
testq %rdi, %rdi
je 0x9f80
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
addq $0x8, %r15
jmp 0x9f5d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_arg_list::fill_and_check(symbol_table*)
void AST_arg_list::fill_and_check(symbol_table* st){
    
    for ( vector<symbol*>::iterator it =args.begin(); it != args.end(); ++it){
        
        int level = 0;
        symbol* prev = st->lookup( (*it)->getName(), &level );
        if ( prev ){
            if ( level != 0 ){
                st->insert( (*it) );
            } else {
                logger->buf << "Argumento '" << (*it)->getName() << "' con identificador repetido.";
                logger->error(line, column);

                break;
            }
        } else {
            st->insert( (*it) );
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rbp
leaq 0x28(%rsp), %r15
leaq 0x4(%rsp), %r12
cmpq 0x18(%rbx), %rbp
je 0xa790
andl $0x0, 0x4(%rsp)
movq (%rbp), %rsi
movq %r15, %rdi
callq 0x13efa
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1422e
movq %rax, %r13
movq %r15, %rdi
callq 0x65c8
testq %r13, %r13
je 0xa71c
cmpl $0x0, 0x4(%rsp)
je 0xa72e
movq (%rbp), %rsi
movq %r14, %rdi
callq 0x142e6
addq $0x8, %rbp
jmp 0xa6dc
leaq 0x2dccb(%rip), %r12     # 0x38400
movq (%r12), %rdi
addq $0x48, %rdi
leaq 0x193c8(%rip), %rsi     # 0x23b0c
callq 0x62b0
movq %rax, %r14
movq (%rbp), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x13efa
movq %r14, %rdi
movq %r15, %rsi
callq 0x62a0
leaq 0x193a9(%rip), %rsi     # 0x23b18
movq %rax, %rdi
callq 0x62b0
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq (%r12), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x16112
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xa7b1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_discrete_arg_list::fill_and_check(symbol_table*)
void AST_discrete_arg_list::fill_and_check(symbol_table* st){
    
    vector< pair<int, int> >::iterator it_boundaries = boundaries.begin();
    
    for ( vector<symbol*>::iterator it =args.begin(); it != args.end(); ++it){
        
        bool verify_types = true;
        
        int level = 0;
        symbol* prev = st->lookup( (*it)->getName(), &level );
        if ( prev ){
            if ( level != 0 ){
                st->insert( (*it) );
                prev = *it;
            } else {
                logger->buf << "Argumento '" << (*it)->getName() << "' con identificador repetido.";
                logger->error(line, column);

                verify_types = false;
                break;
            }
        } else {
            st->insert( (*it) );
            prev = *it;
        }
        
        if ( verify_types ){
            pair<int,int> b = *it_boundaries;
            if ( b.first > b.second ){
                logger->buf << "Argumento '" << (*it)->getName() << "' con rango vacio.";
                logger->error(line, column);
            }
        }
        
        ++it_boundaries;
    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq 0x10(%rdi), %r12
movq %rdi, 0x10(%rsp)
movq 0x28(%rdi), %rbp
leaq 0x38(%rsp), %rbx
movq 0x10(%rsp), %rax
cmpq 0x18(%rax), %r12
je 0xa925
andl $0x0, 0xc(%rsp)
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x13efa
movq %r14, %rdi
movq %rbx, %rsi
leaq 0xc(%rsp), %rdx
callq 0x1422e
movq %rax, %r13
movq %rbx, %rdi
callq 0x65c8
testq %r13, %r13
je 0xa82c
cmpl $0x0, 0xc(%rsp)
je 0xa8b9
movq (%r12), %rsi
movq %r14, %rdi
callq 0x142e6
movl (%rbp), %eax
cmpl 0x4(%rbp), %eax
jle 0xa8ac
leaq 0x2dbb9(%rip), %rax     # 0x38400
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x192b7(%rip), %rsi     # 0x23b0c
callq 0x62b0
movq %rax, %r13
movq (%r12), %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x13efa
movq %r13, %rdi
movq %r15, %rsi
callq 0x62a0
movq %rax, %rdi
leaq 0x192b3(%rip), %rsi     # 0x23b36
callq 0x62b0
leaq 0x18(%rsp), %rdi
callq 0x65c8
leaq 0x2db67(%rip), %rax     # 0x38400
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x16112
addq $0x8, %rbp
addq $0x8, %r12
jmp 0xa7e1
leaq 0x2db40(%rip), %rax     # 0x38400
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x1923e(%rip), %rsi     # 0x23b0c
callq 0x62b0
movq %rax, %r14
movq (%r12), %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x13efa
movq %r14, %rdi
movq %r15, %rsi
callq 0x62a0
leaq 0x1921f(%rip), %rsi     # 0x23b18
movq %rax, %rdi
callq 0x62b0
leaq 0x18(%rsp), %rdi
callq 0x65c8
leaq 0x2daee(%rip), %rax     # 0x38400
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x16112
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa936
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0xa948
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_function::fill_and_check(symbol_table*)
void AST_function::fill_and_check(symbol_table* st){
    
    symbol_table* nested_block = st->new_son();
    
    expected_return = func->getType();
    formal_parameters->fill_and_check(nested_block);
    instructions->fill_and_check(nested_block);
    
    expected_return = UNDEFINED;
    
    delete nested_block;
    
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, %rdi
callq 0x143ac
movq %rax, %rbx
movq 0x98(%r14), %rdi
callq 0x13f0c
movl %eax, 0x2d992(%rip)     # 0x3830c
movq 0xa0(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0xa8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
andl $0x0, 0x2d96b(%rip)     # 0x3830c
testq %rbx, %rbx
je 0xa9ae
movq %rbx, %rdi
callq 0x122be
pushq $0x48
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x62e0
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_assignment::fill_and_check(symbol_table*)
void AST_assignment::fill_and_check(symbol_table* st){
    
    lvalue->fill_and_check(st, true);
    if (0 != expr) {
        expr->fill_and_check(st);
    }
    
    if ( 0 != expr && expr->type != lvalue->type
                && expr->type != INVALID 
                && lvalue->type != INVALID
                && expr->type != UNDEFINED
                && lvalue->type != UNDEFINED
              )
    {
        logger->buf << "Intento de asignación de tipo '"
                    << types.types[expr->type]->name << "' a variable de tipo '"
                    << types.types[lvalue->type]->name << "'.";
        logger->error(line, column);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
movq (%rdi), %rax
pushq $0x1
popq %rdx
callq *0x10(%rax)
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0xae62
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0x80(%rbx), %rcx
testq %rcx, %rcx
je 0xae62
movq 0x78(%rbx), %rax
movl 0x10(%rax), %eax
testl %eax, %eax
je 0xae62
movl 0x10(%rcx), %ecx
testl %ecx, %ecx
je 0xae62
cmpl $0x1, %eax
je 0xae62
cmpl $0x1, %ecx
je 0xae62
cmpl %eax, %ecx
je 0xae62
leaq 0x2d622(%rip), %r14     # 0x38400
movq (%r14), %rdi
addq $0x48, %rdi
leaq 0x18e3c(%rip), %rsi     # 0x23c28
callq 0x62b0
movq 0x80(%rbx), %rcx
movslq 0x10(%rcx), %rcx
leaq 0x2d605(%rip), %r15     # 0x38408
movq (%r15), %rdx
movq (%rdx,%rcx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x18e2c(%rip), %rsi     # 0x23c49
movq %rax, %rdi
callq 0x62b0
movq 0x78(%rbx), %rcx
movslq 0x10(%rcx), %rcx
movq (%r15), %rdx
movq (%rdx,%rcx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x1d750(%rip), %rsi     # 0x28597
movq %rax, %rdi
callq 0x62b0
movq (%r14), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
popq %rbx
popq %r14
popq %r15
jmp 0x16112
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_return::fill_and_check(symbol_table*)
void AST_return::fill_and_check(symbol_table* st){
    
    if ( expected_return == NONE && expr ){
        logger->buf << "No se esperaba retorno con valor.";
        logger->error(line, column);
    } else if ( expected_return != NONE && !expr ){
        logger->buf << "Se esperaba retorno de tipo '"
                    << types.types[expected_return]->name << "'.";
        logger->error(line, column);
    } else if ( expected_return != NONE && expr ){
        expr->fill_and_check(st);
        if ( expr->type != expected_return ){
            logger->buf << "Se esperaba retorno de tipo '"
                        << types.types[expected_return]->name << "', '"
                        << types.types[expr->type]->name << "' obtenido.";
            logger->error(line, column);
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x2d47d(%rip), %eax     # 0x3830c
cmpl $0x2, %eax
setne %cl
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
sete %dl
orb %cl, %dl
je 0xaefd
testq %rdi, %rdi
sete %cl
cmpl $0x2, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xaf33
leaq 0x2d543(%rip), %rax     # 0x38400
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x18db7(%rip), %rsi     # 0x23c82
callq 0x62b0
movslq 0x2d435(%rip), %rcx     # 0x3830c
leaq 0x2d52a(%rip), %rdx     # 0x38408
movq (%rdx), %rdx
movq (%rdx,%rcx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x1d69f(%rip), %rsi     # 0x28597
movq %rax, %rdi
jmp 0xaf12
leaq 0x2d4fc(%rip), %rax     # 0x38400
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x18d4e(%rip), %rsi     # 0x23c60
callq 0x62b0
leaq 0x2d4e2(%rip), %rax     # 0x38400
movq (%rax), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16112
testq %rdi, %rdi
sete %cl
cmpl $0x2, %eax
sete %al
orb %cl, %al
jne 0xaf58
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x78(%rbx), %rax
movl 0x10(%rax), %eax
cmpl 0x2d3b6(%rip), %eax     # 0x3830c
jne 0xaf60
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2d499(%rip), %rax     # 0x38400
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x18d0d(%rip), %rsi     # 0x23c82
callq 0x62b0
movslq 0x2d38b(%rip), %rcx     # 0x3830c
leaq 0x2d480(%rip), %r14     # 0x38408
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x18cfe(%rip), %rsi     # 0x23ca0
movq %rax, %rdi
callq 0x62b0
movq 0x78(%rbx), %rcx
movslq 0x10(%rcx), %rcx
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x18cd9(%rip), %rsi     # 0x23ca5
jmp 0xaef8
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_conditional::fill_and_check(symbol_table*)
void AST_conditional::fill_and_check(symbol_table* st){
    
    if ( expr ){
        expr->fill_and_check(st);
        
        if ( expr->type != BOOLEAN ){
            logger->buf << "Se esperaba boolean.";
            logger->error(expr->line, expr->column);
        }
    }
    
    symbol_table* nested_block = st->new_son();
    blck->fill_and_check(nested_block);
    
    delete nested_block;
    
    if ( else_if ){
        else_if->fill_and_check(st);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0xb025
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x78(%r14), %rax
cmpl $0x6, 0x10(%rax)
je 0xb025
leaq 0x2d400(%rip), %r15     # 0x38400
movq (%r15), %rdi
addq $0x48, %rdi
leaq 0x18ca3(%rip), %rsi     # 0x23cb1
callq 0x62b0
movq (%r15), %rdi
movq 0x78(%r14), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x16112
movq %rbx, %rdi
callq 0x143ac
movq %rax, %r15
movq 0x80(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x8(%rax)
testq %r15, %r15
je 0xb04d
movq %r15, %rdi
callq 0x122be
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0x62e0
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0xb075
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_loop::fill_and_check(symbol_table*)
void AST_loop::fill_and_check(symbol_table* st){
    if (0 != expr) {
        expr->fill_and_check(st);
        if ( expr->type != INVALID && expr->type != BOOLEAN ){
            logger->buf << "Se esperaba boolean.";
            logger->error(line, column);
        }
    }
    
    symbol_table* nested_block = st->new_son();
    blck->fill_and_check(nested_block);
    delete nested_block;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0xb0d2
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0x78(%rbx), %rax
movl 0x10(%rax), %eax
cmpl $0x1, %eax
je 0xb0d2
cmpl $0x6, %eax
je 0xb0d2
leaq 0x2d34f(%rip), %r15     # 0x38400
movq (%r15), %rdi
addq $0x48, %rdi
leaq 0x18bf2(%rip), %rsi     # 0x23cb1
callq 0x62b0
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x16112
movq %r14, %rdi
callq 0x143ac
movq %rax, %r14
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
testq %r14, %r14
je 0xb0fa
movq %r14, %rdi
callq 0x122be
pushq $0x48
popq %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x62e0
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_bounded_loop::fill_and_check(symbol_table*)
void AST_bounded_loop::fill_and_check(symbol_table* st){

    if (0 != left_bound) {
        left_bound->fill_and_check(st);
    }
    if (0 != right_bound) {
        right_bound->fill_and_check(st);
    }
    
    if ( 0 == left_bound || left_bound->type == INVALID
        || 0 == right_bound || right_bound->type == INVALID )
    {
        return;
    } else if ( left_bound->type != right_bound->type ){
        logger->buf << "Ambos límites deben tener el mismo tipo.";
        logger->error(line, column);
    } else if ( left_bound->type != INT
                && left_bound->type != CHAR
                && left_bound->type != BOOLEAN
              )
    {
        logger->buf << "Se esperaba un tipo discreto int, char, boolean.";
        logger->error(line, column);
    }
    
    symbol_table* nested_block = st->new_son();
    
    sym = new symbol(name, true, left_bound->type, line_name, column_name,true);
    nested_block->insert(sym);
    
    blck->fill_and_check(nested_block);
    delete nested_block;
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
testq %rdi, %rdi
je 0xb12e
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0xb143
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0xb253
movl 0x10(%rax), %eax
cmpl $0x1, %eax
je 0xb253
movq 0xb0(%rbx), %rcx
testq %rcx, %rcx
je 0xb253
movl 0x10(%rcx), %ecx
cmpl $0x1, %ecx
je 0xb253
cmpl %ecx, %eax
jne 0xb195
leaq 0x18b6a(%rip), %rsi     # 0x23cf0
cmpl $0x6, %eax
ja 0xb19c
pushq $0x68
popq %rcx
btl %eax, %ecx
jb 0xb1bd
jmp 0xb19c
leaq 0x18b2a(%rip), %rsi     # 0x23cc6
leaq 0x2d25d(%rip), %r15     # 0x38400
movq (%r15), %rdi
addq $0x48, %rdi
callq 0x62b0
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x16112
movq %r14, %rdi
callq 0x143ac
movq %rax, %r14
pushq $0x78
popq %rdi
callq 0x62d0
movq %rax, %r15
leaq 0x78(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x63e0
movq 0xa8(%rbx), %rax
movl 0x10(%rax), %ecx
movl 0xa0(%rbx), %r8d
movl 0xa4(%rbx), %r9d
movl $0x1, (%rsp)
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x13e68
movq %r15, 0x98(%rbx)
leaq 0x10(%rsp), %rdi
callq 0x65c8
movq 0x98(%rbx), %rsi
movq %r14, %rdi
callq 0x142e6
movq 0xb8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x122be
pushq $0x48
popq %rsi
movq %r14, %rdi
callq 0x62e0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x65c8
jmp 0xb26f
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r15, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_read::fill_and_check(symbol_table*)
void AST_read::fill_and_check(symbol_table* st){
    sym = st->lookup(variable);
    
    /* El simbolo existe en la tabla */
    if ( sym ){
        
        /* El simbolo es una function, uso incorrecto como variable */
        if ( sym->is_function ){
            logger->buf << "Identificador '" << sym->getName()
                        << "' definido como función en "
                        << sym->getLine() << ':' << sym->getColumn() << '.';
            logger->error(line, column);
            sym = 0;
        }
    } else {
        /* El simbolo no existe en la tabla */
        logger->buf << "Identificador '" << variable << "' no definido previamente.";
        logger->error(line, column);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x78(%rdi), %r14
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x63e0
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1422e
movq %rax, 0x98(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x65c8
movq 0x98(%rbx), %rax
testq %rax, %rax
je 0xb39a
cmpb $0x1, 0x31(%rax)
jne 0xb3dc
leaq 0x2d116(%rip), %r12     # 0x38400
movq (%r12), %rdi
addq $0x48, %rdi
leaq 0x18593(%rip), %rsi     # 0x2388c
callq 0x62b0
movq %rax, %r14
movq 0x98(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x13efa
movq %r14, %rdi
movq %r15, %rsi
callq 0x62a0
leaq 0x18575(%rip), %rsi     # 0x2389c
movq %rax, %rdi
callq 0x62b0
movq %rax, %r14
movq 0x98(%rbx), %rdi
callq 0x13f10
movq %r14, %rdi
movl %eax, %esi
callq 0x6510
pushq $0x3a
popq %rsi
movq %rax, %rdi
callq 0x6350
movq %rax, %r14
movq 0x98(%rbx), %rdi
callq 0x13f14
movq %r14, %rdi
movl %eax, %esi
callq 0x6510
pushq $0x2e
popq %rsi
movq %rax, %rdi
callq 0x6350
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq (%r12), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x16112
andq $0x0, 0x98(%rbx)
jmp 0xb3dc
leaq 0x2d05f(%rip), %r15     # 0x38400
movq (%r15), %rdi
addq $0x48, %rdi
leaq 0x184dd(%rip), %rsi     # 0x2388c
callq 0x62b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x62a0
leaq 0x1853b(%rip), %rsi     # 0x23901
movq %rax, %rdi
callq 0x62b0
movq (%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x16112
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xb3fa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/constant_folding.cpp
// Function: AST_un_op::constant_folding()
AST_expression* AST_un_op::constant_folding(){
    
    if ( typeid(*expr) == typeid(AST_boolean) && oper_type == NOT){
        tokenBoolean* tk = 
                new tokenBoolean(expr->line,expr->column,(char*)"true");
        AST_boolean* sol = new AST_boolean(tk);
        
        sol->value = !((AST_boolean*)expr)->value;
        return sol;
        
    } else if ( typeid(*expr) == typeid(AST_int) && oper_type == NEG){
        tokenInt* tk = 
                new tokenInt(expr->line,expr->column,(char*)"0");
        AST_int* sol = new AST_int(tk);
        
        sol->value = -((AST_int*)expr)->value;
        return sol;
    } else if ( typeid(*expr) == typeid(AST_float) && oper_type == NEG){
        tokenFloat* tk = 
                new tokenFloat(expr->line,expr->column,(char*)"0.0");
        AST_float* sol = new AST_float(tk);
        
        sol->value = -((AST_float*)expr)->value;
        return sol;
    }
    return this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0xc6ad
movq %rdi, %rbx
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x2aa53(%rip), %rsi     # 0x36fb0
callq 0x1227e
testb %al, %al
je 0xc5b8
cmpl $0x1, 0x48(%rbx)
jne 0xc5b8
pushq $0xc
popq %rdi
callq 0x62d0
movq %rax, %r14
movq 0x50(%rbx), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x16a7c(%rip), %rcx     # 0x23004
movq %r14, %rdi
callq 0x6ae0
pushq $0x50
popq %rdi
callq 0x62d0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x10e9a
movq 0x50(%rbx), %rax
movb 0x48(%rax), %al
xorb $0x1, %al
movb %al, 0x48(%r15)
jmp 0xc6a1
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xc6ad
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x2a9ad(%rip), %rsi     # 0x36f80
callq 0x1227e
testb %al, %al
je 0xc62b
cmpl $0x0, 0x48(%rbx)
jne 0xc62b
pushq $0xc
popq %rdi
callq 0x62d0
movq %rax, %r14
movq 0x50(%rbx), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x1795d(%rip), %rcx     # 0x23f5b
movq %r14, %rdi
callq 0x6b66
pushq $0x50
popq %rdi
callq 0x62d0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x10df2
movq 0x50(%rbx), %rax
xorl %ecx, %ecx
subl 0x48(%rax), %ecx
movl %ecx, 0x48(%r15)
jmp 0xc6a1
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xc6ad
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x2a956(%rip), %rsi     # 0x36f98
callq 0x1227e
testb %al, %al
je 0xc6a4
cmpl $0x0, 0x48(%rbx)
jne 0xc6a4
pushq $0xc
popq %rdi
callq 0x62d0
movq %rax, %r14
movq 0x50(%rbx), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x178ec(%rip), %rcx     # 0x23f59
movq %r14, %rdi
callq 0x6ac4
pushq $0x50
popq %rdi
callq 0x62d0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x10e44
movq 0x50(%rbx), %rax
movss 0x48(%rax), %xmm0
xorps 0x16d95(%rip), %xmm0    # 0x23430
movss %xmm0, 0x48(%r15)
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6320
jmp 0xc6b6
jmp 0xc6b6
movq %rax, %rbx
pushq $0xc
popq %rsi
movq %r14, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_un_op::to_tac(Tac*)
opd *AST_un_op::to_tac(Tac* t){
    opd* e = expr->to_tac(t);
    
    switch( oper_type ){
        case NOT:
            falselist = expr->truelist;
            truelist  = expr->falselist;
            break;
        default:
            {
                opd* d = new opd();
                t->append_quad(inst::UMINUS, d, e, 0, "operación binaria de inverso");
                
                return d;
            }
            break;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, 0x48(%rbx)
jne 0xd97a
movq 0x50(%rbx), %rsi
addq $0x18, %rsi
leaq 0x30(%rbx), %rdi
callq 0x12420
movq 0x50(%rbx), %rsi
addq $0x30, %rsi
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x12420
xorl %ebx, %ebx
jmp 0xd9c9
movq %rax, %r15
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x18148
leaq 0x16af2(%rip), %rsi     # 0x24489
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
pushq $0x15
popq %rsi
leaq 0x10(%rsp), %r9
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x212de
leaq 0x10(%rsp), %rdi
callq 0x65c8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x65c8
jmp 0xd9f8
movq %rax, %r14
jmp 0xd9f8
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x62e0
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_boolean::to_tac(Tac*)
opd *AST_boolean::to_tac(Tac* t){
    if ( value ){
        truelist.clear();
        truelist.push_back(t->next_instruction());
    } else {
        falselist.clear();
        falselist.push_back(t->next_instruction());
    }
    t->append_quad(inst::GOTO, 0, 0, 0, "salto condicional de booleano");
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x48(%rdi)
jne 0xdc9d
addq $0x18, %r14
jmp 0xdca1
addq $0x30, %r14
movq %r14, %rdi
callq 0x124ce
movq %rbx, %rdi
callq 0x2138a
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x1243c
leaq 0x1680d(%rip), %rsi     # 0x244d4
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x6d6c
pushq $0x16
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x212de
leaq 0x8(%rsp), %rdi
callq 0x65c8
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_lval::gen_tac_lval_disp(Tac*, opd*, int*)
opd *AST_lval::gen_tac_lval_disp(Tac* t, opd *din_base, int *sta_base){
    opd *o;
    if (0 != *sta_base) {
        o = new opd();
        t->append_quad(inst::ADD, o, din_base, new opd(*sta_base), "sumar base estática a base dinámica (no se pudo retrasar más la suma)");
    } else {
        o = din_base;
    }
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
cmpl $0x0, (%rdx)
je 0xddcb
movq %rdx, %r13
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x18148
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %r12
movl (%r13), %esi
pushq $0x2
popq %rdx
movq %rax, %rdi
callq 0x1815e
leaq 0x1679d(%rip), %rsi     # 0x24534
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
pushq $0x11
popq %rsi
leaq 0x10(%rsp), %r9
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
callq 0x212de
leaq 0x10(%rsp), %rdi
callq 0x65c8
jmp 0xddce
movq %r14, %rbx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x65c8
jmp 0xde0c
movq %rax, %r14
jmp 0xde0c
movq %rax, %r14
pushq $0x18
popq %rsi
movq %r12, %rdi
jmp 0xde07
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x62e0
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_dereference::gen_tac_lval(Tac*, int*)
opd *AST_dereference::gen_tac_lval(Tac* t, int *sta_base){
    opd *o = value->gen_tac_lval(t, sta_base), *d = new opd();
    o = gen_tac_lval_disp(t, o, sta_base);
    t->append_quad(inst::DEREF, d, o, 0, "dereferenciar un lvalue");
    return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r12
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x18148
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xdd48
movq %rax, %r15
leaq 0x16698(%rip), %rsi     # 0x2457d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6d6c
pushq $0x4
popq %rsi
leaq 0x8(%rsp), %r9
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x212de
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x65c8
jmp 0xdf48
movq %rax, %r14
jmp 0xdf48
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x62e0
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/to_tac.cpp
// Function: AST_address::gen_tac_lval(Tac*, int*)
opd *AST_address::gen_tac_lval(Tac* t, int *sta_base){
    opd *o = value->gen_tac_lval(t, sta_base), *r = new opd();
    o = gen_tac_lval_disp(t, o, sta_base);
    t->append_quad(inst::REF, r, o, 0, "referenciar un lvalue");
    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r12
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x18148
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xdd48
movq %rax, %r15
leaq 0x165e6(%rip), %rsi     # 0x2457f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6d6c
pushq $0x3
popq %rsi
leaq 0x8(%rsp), %r9
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x212de
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x65c8
jmp 0xdffc
movq %rax, %r14
jmp 0xdffc
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x62e0
movq %r14, %rdi
callq 0x6530