LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_variable_declaration::AST_variable_declaration(int, tokenId*, AST_expression*, bool)
AST_variable_declaration::AST_variable_declaration(TYPE t, tokenId* id,
                                                   AST_expression* v,
                                                   bool constant
                                                  )
{
    line = id->line;
    column = id->column;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x68(%rdi)
movq %rcx, 0x60(%rdi)
movq %rax, 0x70(%rdi)
leaq 0x88(%rdi), %rcx
movq %rcx, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movb $0x0, 0x88(%rdi)
leaq 0x28164(%rip), %rax     # 0x3d4f8
movq %rax, (%rdi)
movq (%rdx), %rax
movq %rax, 0x8(%rdi)
movl $0x78, %edi
callq 0x62e0
movq %rax, %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x16c42
movl (%r15), %r8d
movl 0x4(%r15), %r9d
xorl %eax, %eax
testq %r14, %r14
setne %al
movl %eax, (%rsp)
movzbl %r13b, %edx
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movl %ebp, %ecx
callq 0x17f0e
movq %r12, 0x98(%rbx)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x15411
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq $0x0, 0x10(%r15)
movq 0x8(%r15), %rax
movb $0x0, (%rax)
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0x15438
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %r15, %rdi
callq 0x62f0
movq %r14, 0xa0(%rbx)
movl $0x1, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x15486
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
jmp 0x15486
movq %rax, %r14
movl $0x78, %esi
movq %r12, %rdi
callq 0x62f0
jmp 0x15498
movq %rax, %r14
movq %rbx, %rdi
callq 0x1697e
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_block::add_statement(AST_statement*)
void AST_block::add_statement(AST_statement* s){

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

    has_return = s->has_return;

    statements.push_back(s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movq 0x80(%rdi), %rax
movq 0x88(%rdi), %rdx
movq %rdx, %rcx
subq %rax, %rcx
je 0x155b9
movq -0x8(%rdx), %rdx
movl 0x10(%rdx), %edx
cmpl $0x2, %edx
je 0x155ac
testl %edx, %edx
jne 0x155b9
cmpq $0x9, %rcx
jb 0x155f7
movq -0x10(%rax,%rcx), %rax
cmpl $0x0, 0x10(%rax)
je 0x1559f
leaq 0x28e8b(%rip), %r14     # 0x3e400
movq (%r14), %rdi
addq $0x48, %rdi
leaq 0x18bb1(%rip), %rsi     # 0x2e134
movl $0x13, %edx
callq 0x6360
movq (%r14), %rdi
movq (%rsp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x1a814
movq (%rsp), %rax
movl $0x0, 0x10(%rax)
jmp 0x155b9
cmpl $0x0, 0x10(%rsi)
je 0x155b9
movl $0x2, 0x10(%rsi)
movq (%rsp), %rax
movl 0x10(%rax), %ecx
movl %ecx, 0x78(%rbx)
movq 0x88(%rbx), %rsi
cmpq 0x90(%rbx), %rsi
je 0x155e0
movq %rax, (%rsi)
addq $0x8, 0x88(%rbx)
jmp 0x155ef
subq $-0x80, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x177c2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq $0x8, %rcx
je 0x1556e
jmp 0x1559f
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_arg_list::add_argument(int, tokenId*, bool)
void AST_arg_list::add_argument( TYPE t, tokenId* id, bool constant ){
    symbol* next_arg = new symbol(id->ident, constant, t,
                                  id->line, id->column, false);
    
    args.push_back( next_arg );
    
    line = args[0]->getLine();
    
    delete id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movl $0x78, %edi
callq 0x62e0
movq %rax, %r14
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x16c42
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
movl $0x0, (%rsp)
movzbl %r12b, %edx
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
movl %ebp, %ecx
callq 0x17f0e
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x1569a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x62f0
movq %r14, 0x10(%rsp)
movq 0x18(%r15), %rsi
cmpq 0x20(%r15), %rsi
je 0x156b3
movq %r14, (%rsi)
addq $0x8, 0x18(%r15)
jmp 0x156c1
leaq 0x10(%r15), %rdi
leaq 0x10(%rsp), %rdx
callq 0x178fe
movq 0x10(%r15), %rax
movq (%rax), %rdi
callq 0x17fe2
movl %eax, 0x8(%r15)
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x156f8
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %rbx, %rdi
callq 0x62f0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x15733
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x62f0
jmp 0x15733
movq %rax, %rbx
movl $0x78, %esi
movq %r14, %rdi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_discrete_arg_list::add_argument(int, tokenId*, int, int, bool)
void AST_discrete_arg_list::add_argument( TYPE t, tokenId* id,
                                          int min_value, int max_value,
                                          bool constant )
{
    symbol* next_arg = new symbol(id->ident, constant, t,
                                  id->line, id->column, false);
    
    args.push_back( next_arg );
    boundaries.push_back( pair<int,int>(min_value, max_value) );
    
    line = args[0]->getLine();
    
    delete id;
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movl %r8d, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movq %rdx, %rbx
movl %esi, %r13d
movq %rdi, %r14
movl $0x78, %edi
callq 0x62e0
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x16c42
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
movl $0x0, (%rsp)
movzbl %bpl, %edx
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
movl %r13d, %ecx
callq 0x17f0e
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x157f0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x62f0
movq %r15, 0x18(%rsp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x15809
movq %r15, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x15817
leaq 0x10(%r14), %rdi
leaq 0x18(%rsp), %rdx
callq 0x178fe
leaq 0x28(%r14), %rdi
leaq 0x40(%rsp), %rsi
movl 0x10(%rsp), %eax
movl %eax, (%rsi)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsi)
callq 0x17a3a
movq 0x10(%r14), %rax
movq (%rax), %rdi
callq 0x17fe2
movl %eax, 0x8(%r14)
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x15869
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %rbx, %rdi
callq 0x62f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x158a4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x62f0
jmp 0x158a4
movq %rax, %rbx
movl $0x78, %esi
movq %r15, %rdi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_procedure_call::AST_procedure_call(tokenId*, AST_parameters_list*)
AST_procedure_call::AST_procedure_call(tokenId* tk, AST_parameters_list* p){
    funcall = new AST_function_call(tk, p);
    funcall->returns_value = false;
    line = funcall->line;
    column = funcall->column;
    has_return = NO;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x68(%rdi)
movq %rcx, 0x60(%rdi)
movq %rax, 0x70(%rdi)
leaq 0x278ea(%rip), %rax     # 0x3d610
movq %rax, (%rdi)
movl $0x88, %edi
callq 0x62e0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x151aa
movq %r12, 0x78(%rbx)
movb $0x0, 0x78(%r12)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x88, %esi
movq %r12, %rdi
callq 0x62f0
jmp 0x15d7f
movq %rax, %r14
movq %rbx, %rdi
callq 0x16a44
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_return::AST_return(token*, AST_expression*)
AST_return::AST_return(token* tk, AST_expression* e){

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

    expr = e;
    has_return = YES;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rcx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
leaq 0x30(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rdx, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
leaq 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x27852(%rip), %rcx     # 0x3d638
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x62f0
movq %rbx, 0x78(%r14)
movl $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_conditional::AST_conditional(token*, AST_expression*, AST_block*, AST_conditional*)
AST_conditional::AST_conditional(token* tk, AST_expression* e, AST_block* b,
                                 AST_conditional* branches)
{
    line = tk->line;
    column = tk->column;
    delete tk;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rcx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
leaq 0x30(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rdx, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
leaq 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x277ee(%rip), %rcx     # 0x3d660
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x62f0
movq %r15, 0x78(%rbx)
movq %r12, 0x80(%rbx)
movq %r14, 0x88(%rbx)
movl 0x78(%r12), %ecx
movl %ecx, 0x10(%rbx)
testq %r14, %r14
je 0x15ec2
movl $0x2, %eax
cmpl $0x1, %ecx
je 0x15ed3
testl %ecx, %ecx
jne 0x15ede
movl 0x10(%r14), %ecx
cmpl $0x1, %ecx
cmovnel %ecx, %eax
jmp 0x15ede
testq %r15, %r15
je 0x15edc
movl $0x2, %eax
cmpl $0x1, %ecx
jne 0x15ede
jmp 0x15ee1
cmpl $0x1, 0x10(%r14)
jne 0x15ede
jmp 0x15ee1
movl %ecx, %eax
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_loop::AST_loop(token*, AST_expression*, AST_block*)
AST_loop::AST_loop(token* tk, AST_expression* e, AST_block* b)
{
    line = tk->line;
    column = tk->column;
    delete tk;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rcx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
leaq 0x30(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rdx, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
leaq 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x27748(%rip), %rcx     # 0x3d690
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x62f0
movq %r15, 0x78(%rbx)
movq %r14, 0x80(%rbx)
xorl %eax, %eax
cmpl $0x1, 0x78(%r14)
setne %al
incl %eax
movl %eax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_bounded_loop::AST_bounded_loop(token*, tokenId*, AST_expression*, AST_expression*, AST_block*)
AST_bounded_loop::AST_bounded_loop(token* for_, tokenId* id,
                                   AST_expression* l,
                                   AST_expression* r,
                                   AST_block* b)
{
    line = for_->line;
    column = for_->column;
    delete for_;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rcx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
leaq 0x30(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rdx, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
leaq 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x276cb(%rip), %rdx     # 0x3d6b8
movq %rdx, (%rdi)
leaq 0x78(%rdi), %rbp
leaq 0x88(%rdi), %r15
movq %r15, 0x78(%rdi)
movq %rcx, 0x80(%rdi)
movb $0x0, 0x88(%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x62f0
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x16c42
leaq 0x18(%rsp), %r15
movq %rbp, %rdi
movq %r15, %rsi
callq 0x63c0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x16065
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x62f0
movq (%r13), %rax
movq %rax, 0xa0(%rbx)
movq $0x0, 0x10(%r13)
movq 0x8(%r13), %rax
movb $0x0, (%rax)
movq 0x8(%r13), %rdi
leaq 0x18(%r13), %rax
cmpq %rax, %rdi
je 0x16097
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %r13, %rdi
callq 0x62f0
movq 0x8(%rsp), %rax
movq %rax, 0xa8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0xb0(%rbx)
movq $0x0, 0x98(%rbx)
movq %r14, 0xb8(%rbx)
xorl %eax, %eax
cmpl $0x1, 0x78(%r14)
setne %al
incl %eax
movl %eax, 0x10(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbp), %rdi
cmpq %r15, %rdi
je 0x16103
movq (%r15), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x16a44
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_break::AST_break(token*)
AST_break::AST_break(token* t){
    line = t->line;
    column = t->column;
    delete t;
    
    has_return = NO;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rcx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
leaq 0x30(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rdx, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
leaq 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x2757c(%rip), %rcx     # 0x3d6e0
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x62f0
movl $0x1, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_continue::AST_continue(token*)
AST_continue::AST_continue(token* t){
    line = t->line;
    column = t->column;
    delete t;
    
    has_return = NO;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rcx, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
leaq 0x30(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rdx, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
leaq 0x48(%rdi), %rdx
movq %rdx, 0x50(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
movq %rdx, 0x60(%rdi)
movq %rcx, 0x70(%rdi)
leaq 0x27534(%rip), %rcx     # 0x3d708
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl $0x8, %esi
movq %rax, %rdi
callq 0x62f0
movl $0x1, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_read::AST_read(tokenId*)
AST_read::AST_read(tokenId* t){
    line = t->line;
    column = t->line;
    
    variable = string(t->ident);
    delete t;
    
    has_return = NO;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x68(%rdi)
movq %rcx, 0x60(%rdi)
movq %rax, 0x70(%rdi)
leaq 0x274e0(%rip), %rcx     # 0x3d730
movq %rcx, (%rdi)
leaq 0x78(%rdi), %r15
leaq 0x88(%rdi), %r12
movq %r12, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movb $0x0, 0x88(%rdi)
movl (%rsi), %eax
movl %eax, 0x8(%rdi)
movl %eax, 0xc(%rdi)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x16c42
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63c0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x162b8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
movq $0x0, 0x10(%r14)
movq 0x8(%r14), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x162df
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %r14, %rdi
callq 0x62f0
movl $0x1, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x16318
movq (%r12), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x16a44
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_print::add_argument(AST_expression*)
void AST_print::add_argument(AST_expression* e){
    list.push_back(e);
    
    if ( list.size() == 1 ){
        line   = e->line;
        column = e->column;
    }
    has_return = NO;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x68(%rdi)
movq %rcx, 0x60(%rdi)
movq %rax, 0x70(%rdi)
leaq 0x27334(%rip), %rcx     # 0x3d780
movq %rcx, (%rdi)
leaq 0x80(%rdi), %r15
leaq 0x90(%rdi), %r12
movq %r12, 0x80(%rdi)
movq %rax, 0x88(%rdi)
movb $0x0, 0x90(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0xc(%rdi)
movq %rsi, 0x78(%rdi)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rdx), %rsi
movq 0x10(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x16c42
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63c0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x164c2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
movq $0x0, 0xa0(%rbx)
testq %r14, %r14
je 0x16506
movq $0x0, 0x10(%r14)
movq 0x8(%r14), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x164f9
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %r14, %rdi
callq 0x62f0
movl $0x1, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x16532
movq (%r12), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x16a44
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_map::AST_map(AST_expression*, AST_expression*, tokenId*)
AST_map::AST_map(AST_expression* s, AST_expression* d, tokenId* f){
    line = s->line;
    column = s->line;
    
    src = s;
    dst = d;
    
    function = string(f->ident);
    sym = 0;
    delete f;
    
    has_return = NO;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x68(%rdi)
movq %rcx, 0x60(%rdi)
movq %rax, 0x70(%rdi)
leaq 0x2720a(%rip), %rcx     # 0x3d7a8
movq %rcx, (%rdi)
leaq 0x88(%rdi), %r15
leaq 0x98(%rdi), %r12
movq %r12, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movb $0x0, 0x98(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0xc(%rdi)
movq %rsi, 0x78(%rdi)
movq %rdx, 0x80(%rdi)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x16c42
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63c0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x1661b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x62f0
movq $0x0, 0xa8(%rbx)
testq %r14, %r14
je 0x1665f
movq $0x0, 0x10(%r14)
movq 0x8(%r14), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x16652
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %r14, %rdi
callq 0x62f0
movl $0x1, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1668b
movq (%r12), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x16a44
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/lib/symbol_table.h
// Function: symbol_table::~symbol_table()
~symbol_table(){
            /* Verificar si hay simbolos sin ser utilizados en el bloque */
            map<string, symbol*>::iterator it;
            for (it = table.begin(); it != table.end(); ++it){
                symbol* sym = it->second;
                if ( sym->unused && !sym->is_function ){
                    logger->buf << "Identificador sin utilizar '" << sym->getName() << "'.";
                    logger->warning(sym->getLine(), sym->getColumn());
                }
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %r14
leaq 0x20(%rdi), %r13
cmpq %r13, %r14
je 0x167c3
movq 0x40(%r14), %rbp
cmpb $0x1, 0x32(%rbp)
jne 0x167af
cmpb $0x0, 0x31(%rbp)
jne 0x167af
leaq 0x27ce5(%rip), %rax     # 0x3e400
movq (%rax), %r15
addq $0x48, %r15
movl $0x1c, %edx
movq %r15, %rdi
leaq 0x17a42(%rip), %rsi     # 0x2e173
callq 0x6360
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x17fb8
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x6360
movl $0x2, %edx
movq %rax, %rdi
leaq 0x1ae33(%rip), %rsi     # 0x31597
callq 0x6360
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16785
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
leaq 0x27c74(%rip), %rax     # 0x3e400
movq (%rax), %r15
movq %rbp, %rdi
callq 0x17fe2
movl %eax, %r12d
movq %rbp, %rdi
callq 0x17fe6
movq %r15, %rdi
movl %r12d, %esi
movl %eax, %edx
callq 0x1a814
movq %r14, %rdi
callq 0x6200
movq %rax, %r14
cmpq %r13, %rax
jne 0x166fc
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x16b02
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x16af7
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/utils.cpp
// Function: lcm(int, int)
int lcm(int a, int b){
    if ( a == 0 && b == 0 ){
        return 1; // lcm se utiliza para obtener la alineacion comun de un
                  // conjunto de datos, si todos tienen tamaño cero la
                  // alineacion es de cualquier byte
    }
    return abs((double)a*b)/gcd(a,b);
}

// Assembly:
movl %esi, %eax
orl %edi, %eax
je 0x17e5d
subq $0x18, %rsp
cvtsi2sd %edi, %xmm0
cvtsi2sd %esi, %xmm1
mulsd %xmm0, %xmm1
andpd 0x163d6(%rip), %xmm1    # 0x2e210
movapd %xmm1, (%rsp)
callq 0x17e0c
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movapd (%rsp), %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
addq $0x18, %rsp
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/utils.cpp
// Function: itoa_(int)
char* itoa_(int i){
    char* s = new char[12];
    int k = 12;
    s[--k] = 0;
    while (i > 0) {
        s[--k] = '0' + (i % 10);
        i /= 10;
    }
    if (0 < k) {
        for (int i = 0; i + k < 12; ++ i) {
            s[i] = s[i + k];
        }
    }
    return s;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl $0xc, %edi
callq 0x6030
movb $0x0, 0xb(%rax)
testl %ebx, %ebx
jle 0x17eae
movl $0xa, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %ebx, %esi
imulq %rdx, %rsi
shrq $0x23, %rsi
leal (%rsi,%rsi), %edi
leal (%rdi,%rdi,4), %edi
movl %ebx, %r8d
subl %edi, %r8d
orb $0x30, %r8b
movb %r8b, (%rax,%rcx)
decq %rcx
cmpl $0x9, %ebx
movl %esi, %ebx
ja 0x17e82
incl %ecx
jmp 0x17eb3
movl $0xb, %ecx
leal -0x1(%rcx), %edx
cmpl $0xa, %edx
ja 0x17edc
movl %ecx, %esi
movl $0xc, %edx
subl %ecx, %edx
movq %rax, %rcx
addq %rsi, %rcx
xorl %esi, %esi
movb (%rcx,%rsi), %dil
movb %dil, (%rax,%rsi)
incq %rsi
cmpq %rsi, %rdx
jne 0x17ecc
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/symbol.cpp
// Function: symbol::symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, int, int, int, bool)
symbol::symbol(string name, bool constant, TYPE type, int line,
               int column, bool initialized)
{
    //al construir se puede validar que no sea NONE!
    this->name = name;
    this->constant = constant;
    this->type = type;
    this->line = line;
    this->column = column;
    this->initialized = initialized;
    this->is_function = false;
    
    this->width = 0;
    this->alignment = 1;
    this->offset = 0;
    this->index = -1;
    
    this->unused = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x50(%rdi), %rcx
movl $0x0, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
movq %rcx, 0x68(%rdi)
movq %rax, 0x70(%rdi)
callq 0x6180
movb 0x40(%rsp), %al
movb %r12b, 0x20(%rbx)
movl %r15d, 0x24(%rbx)
movl %r14d, 0x28(%rbx)
movl %ebp, 0x2c(%rbx)
movb %al, 0x30(%rbx)
movw $0x100, 0x31(%rbx)      # imm = 0x100
movaps 0x162a4(%rip), %xmm0    # 0x2e220
movups %xmm0, 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x48(%rbx), %rdi
callq 0x18228
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x17faf
movq (%r13), %rsi
incq %rsi
callq 0x62f0
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/symbol.cpp
// Function: symbol_function::symbol_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, std::vector<int, std::allocator<int>>&)
symbol_function::symbol_function(string name, int line, int column,
                                 vector<TYPE>& types
                                )
{
    this->name = name;
    this->type = NONE;
    this->constant = true;
    
    this->line = line;
    this->column = column;
    this->initialized = false;
    this->is_function = true;
    this->unused = true;

    this->alignment = -1;
    this->index = -1;
    
    vector< TYPE >::iterator it;
    for ( it = types.begin(); it != types.end(); ++it ){
        this->params.push_back( *it );
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r12d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x50(%rdi), %rcx
movl $0x0, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
movq %rcx, 0x68(%rdi)
leaq 0x78(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x80(%rdi)
callq 0x6180
movl $0x2, 0x24(%rbx)
movb $0x1, %al
movb %al, 0x20(%rbx)
movl %r12d, 0x28(%rbx)
movl %ebp, 0x2c(%rbx)
movw $0x100, 0x30(%rbx)      # imm = 0x100
movb %al, 0x32(%rbx)
movq $-0x1, 0x3c(%rbx)
movq (%r14), %r12
cmpq 0x8(%r14), %r12
je 0x180d9
movq 0x80(%rbx), %rsi
cmpq 0x88(%rbx), %rsi
je 0x180c8
movl (%r12), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x80(%rbx)
jmp 0x180d3
movq %r15, %rdi
movq %r12, %rdx
callq 0x18278
addq $0x4, %r12
jmp 0x1809f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x180e4
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x180fe
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x18200
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/symbol_table.cpp
// Function: symbol_table::lookup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int*)
symbol* symbol_table::lookup(string name, int* level){
    map<string, symbol*>::iterator iter;
    if ( table.find(name) != table.end() ){
        if (level){
            *level = 0;
        }
        return table[name];
    }
    
    if (0 != parent){
        symbol* s = parent->lookup(name, level);
        
        if ( level){
            *level = *level + 1;
        }
        return s;
    }
    
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x188f6
leaq 0x20(%r12), %rcx
cmpq %rcx, %rax
je 0x18400
testq %rbx, %rbx
je 0x183e3
movl $0x0, (%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x185d6
movq (%rax), %r14
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r12), %r15
testq %r15, %r15
je 0x1845b
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x16c42
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x183ae
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x18452
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
testq %rbx, %rbx
je 0x183f1
incl (%rbx)
jmp 0x183f1
xorl %r14d, %r14d
jmp 0x183f1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1847a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/symbol_table.cpp
// Function: symbol_table::insert(symbol*)
void symbol_table::insert(symbol* s){
    table[s->getName()] = s;
    
    accumulate_offset( 0, s->alignment );
    s->offset = accumulated_offset;
    s->index = ++ counter;
    
    accumulate_offset( s->width, s->alignment );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x17fb8
movq %r15, %rdi
movq %r12, %rsi
callq 0x18652
movq %r14, (%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x184f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movl 0x3c(%r14), %esi
testl %esi, %esi
jle 0x18513
movl 0xc(%rbx), %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %esi, %eax
subl %edx, %eax
xorl %edx, %edx
divl %esi
addl %ecx, %edx
movl %edx, 0xc(%rbx)
movl 0xc(%rbx), %ecx
movl %ecx, 0x34(%r14)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movl %eax, 0x40(%r14)
testl %esi, %esi
jle 0x18541
movl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %esi, %eax
subl %edx, %eax
xorl %edx, %edx
divl %esi
addl 0x38(%r14), %ecx
addl %edx, %ecx
movl %ecx, 0xc(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1856b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/symbol_table.cpp
// Function: symbol_table::accumulate_offset(int, int)
void symbol_table::accumulate_offset(int width, int alignment){
    
    if ( alignment <= 0 ){
        return;
    }
    
    accumulated_offset += (alignment
                            - (accumulated_offset % alignment)) % alignment;
    
    accumulated_offset += width;
}

// Assembly:
testl %edx, %edx
jle 0x18595
movl %edx, %ecx
movl 0xc(%rdi), %r8d
movl %r8d, %eax
xorl %edx, %edx
divl %ecx
movl %ecx, %eax
subl %edx, %eax
xorl %edx, %edx
divl %ecx
addl %r8d, %esi
addl %edx, %esi
movl %esi, 0xc(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/type_descriptor.cpp
// Function: struct_type::struct_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, symbol_table*)
struct_type::struct_type(string n, symbol_table* st){
    name = n;
    width = st->accumulated_offset;
    alignment = 4;
    fields = st;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %r15
movq %r15, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x28(%rbx)
leaq 0x24da6(%rip), %rax     # 0x3dbb8
movq %rax, (%rbx)
callq 0x6180
movl 0xc(%r14), %eax
movl %eax, 0x28(%rbx)
movl $0x4, 0x2c(%rbx)
movq %r14, 0x30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x24d64(%rip), %rax     # 0x3dba0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x18e53
movq (%r15), %rsi
incq %rsi
callq 0x62f0
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/type_descriptor.cpp
// Function: union_type::union_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, symbol_table*)
union_type::union_type(string n, symbol_table* st){
    name = n;
    width = 0;
    alignment = 1;
    fields = st;
    
    map<string, symbol*>::iterator it;
    for (it = fields->table.begin(); it != fields->table.end(); ++it){
        (*it).second->offset = 0;
        width = max(width, types.types[(*it).second->getType()]->width );
        
        alignment = lcm(alignment,
                        types.types[(*it).second->getType()]->alignment );
    }
    // entero de 4 bytes para indicar posici�n en uso actualmente
    width += 4;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %r12
movq %r12, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movabsq $0x100000000, %r14      # imm = 0x100000000
movq %r14, 0x28(%rbx)
leaq 0x24d39(%rip), %rax     # 0x3dbd0
movq %rax, (%rbx)
callq 0x6180
movq %r14, 0x28(%rbx)
movq %r15, 0x30(%rbx)
movq 0x30(%r15), %r14
addq $0x20, %r15
cmpq %r15, %r14
je 0x18f1c
leaq 0x2554d(%rip), %r15     # 0x3e408
movq 0x40(%r14), %rdi
movl $0x0, 0x34(%rdi)
callq 0x17fde
cltq
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
movl 0x28(%rax), %eax
movl 0x28(%rbx), %ecx
movl 0x2c(%rbx), %ebp
cmpl %eax, %ecx
cmovgl %ecx, %eax
movl %eax, 0x28(%rbx)
movq 0x40(%r14), %rdi
callq 0x17fde
cltq
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
movl 0x2c(%rax), %esi
movl %ebp, %edi
callq 0x17e1c
movl %eax, 0x2c(%rbx)
movq %r14, %rdi
callq 0x6200
movq %rax, %r14
movq 0x30(%rbx), %rax
addq $0x20, %rax
cmpq %rax, %r14
jne 0x18ebb
addl $0x4, 0x28(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18f2b
movq %rax, %r14
leaq 0x24c6b(%rip), %rax     # 0x3dba0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq %r12, %rdi
je 0x18f4d
movq (%r12), %rsi
incq %rsi
callq 0x62f0
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/type_descriptor.cpp
// Function: enum_type::enum_type(tokenId*, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
enum_type::enum_type( tokenId* tk, set<string>* v)
{
    width = 4;
    alignment = 4;
    line = tk->line;
    column = tk->column;
    name = tk->ident;
    values = v;

    delete tk;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rdi
leaq 0x18(%r14), %r12
movq %r12, 0x8(%r14)
movq $0x0, 0x10(%r14)
movb $0x0, 0x18(%r14)
leaq 0x24c61(%rip), %rax     # 0x3dbe8
movq %rax, (%r14)
movabsq $0x400000004, %rax      # imm = 0x400000004
movq %rax, 0x28(%r14)
movq (%rsi), %rax
movq %rax, 0x30(%r14)
addq $0x8, %rsi
callq 0x6180
movq %r15, 0x38(%r14)
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x18fd3
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x62f0
movq %rax, %rbx
leaq 0x24bab(%rip), %rax     # 0x3dba0
movq %rax, (%r14)
movq 0x8(%r14), %rdi
cmpq %r12, %rdi
je 0x1900d
movq (%r12), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/type_descriptor.cpp
// Function: array_descriptor::array_descriptor(type_descriptor*, int, int, int)
array_descriptor::array_descriptor( type_descriptor* b, TYPE b_ind, int up,
                                    int low )
{
    stringstream ss;
    ss << "array"
       << "("
       << low
       << ","
       << up
       << ")_of_"
       << b->name;
    ss >> name;
    
    unsigned int base_width = b->width;
    base_width += (b->alignment - (base_width) % b->alignment ) % b->alignment;
    
    width = base_width * ( up - low );
    alignment = b->alignment;
    
    lower_index = low;
    upper_index = up;
    num_elements = up - low;
    
    base = b_ind;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %r8d, %r15d
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x28(%rdi)
leaq 0x24bf5(%rip), %rax     # 0x3dc58
movq %rax, (%rdi)
leaq 0x10(%rsp), %rdi
callq 0x6210
leaq 0x20(%rsp), %r13
leaq 0x151c4(%rip), %rsi     # 0x2e240
movl $0x5, %edx
movq %r13, %rdi
callq 0x6360
leaq 0x13460(%rip), %rsi     # 0x2c4f0
movl $0x1, %edx
movq %r13, %rdi
callq 0x6360
movq %r13, %rdi
movl %r15d, %esi
callq 0x6530
movq %rax, %r13
leaq 0x135e0(%rip), %rsi     # 0x2c692
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
movq %r13, %rdi
movl %r14d, %esi
callq 0x6530
movq %rax, %r13
leaq 0x15172(%rip), %rsi     # 0x2e246
movl $0x5, %edx
movq %rax, %rdi
callq 0x6360
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r13, %rdi
callq 0x6360
leaq 0x8(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x63e0
movl 0x28(%r12), %ecx
movl 0x2c(%r12), %esi
movl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %esi, %eax
subl %edx, %eax
xorl %edx, %edx
divl %esi
addl %ecx, %edx
movl %r14d, %eax
subl %r15d, %eax
imull %eax, %edx
movl %edx, 0x28(%rbx)
movl %esi, 0x2c(%rbx)
movl %r15d, 0x30(%rbx)
movl %r14d, 0x34(%rbx)
movl %eax, 0x38(%rbx)
movl %ebp, 0x3c(%rbx)
movq 0x24e49(%rip), %rsi     # 0x3df88
leaq 0x10(%rsp), %rdi
callq 0x6240
leaq 0x90(%rsp), %rdi
callq 0x6100
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1918e
movq %rax, %r14
movq 0x24e11(%rip), %rsi     # 0x3df88
leaq 0x10(%rsp), %rdi
callq 0x6240
leaq 0x90(%rsp), %rdi
callq 0x6100
leaq 0x24a0b(%rip), %rax     # 0x3dba0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x191b3
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x62f0
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/type_descriptor.cpp
// Function: pointer_descriptor::pointer_descriptor(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
pointer_descriptor::pointer_descriptor(TYPE b_index, string base_name){
    base = b_index;

    stringstream ss;
    ss << "pointer_to_"
       << base_name;
    ss >> name;

    width = 4;
    alignment = 4;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x28(%rdi)
leaq 0x24a77(%rip), %rax     # 0x3dc70
movq %rax, (%rdi)
movl %esi, 0x30(%rdi)
movq %rsp, %rdi
callq 0x6210
leaq 0x10(%rsp), %r15
leaq 0x15039(%rip), %rsi     # 0x2e24c
movl $0xb, %edx
movq %r15, %rdi
callq 0x6360
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x6360
leaq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x63e0
movabsq $0x400000004, %rax      # imm = 0x400000004
movq %rax, 0x28(%rbx)
movq 0x24d38(%rip), %rsi     # 0x3df88
movq %rsp, %rdi
callq 0x6240
leaq 0x80(%rsp), %rdi
callq 0x6100
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x19298
movq %rax, %r14
movq 0x24d05(%rip), %rsi     # 0x3df88
movq %rsp, %rdi
callq 0x6240
leaq 0x80(%rsp), %rdi
callq 0x6100
leaq 0x24901(%rip), %rax     # 0x3dba0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq %r12, %rdi
je 0x192b7
movq (%r12), %rsi
incq %rsi
callq 0x62f0
movq %r14, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/type_descriptor.cpp
// Function: enum_type::dump(std::ostream&)
void enum_type::dump(ostream &strm){
    strm << "  * enum " << name << " [size " << width
         << "][alignment " << alignment << "]" << endl
         << "    ---" << endl;
    set<string>::iterator it;
    for (it = values->begin(); it != values->end(); ++it){
        strm << "    |   - " << (*it).c_str() << endl;
    }
    if ( values->begin() == values->end() ){
        strm << "    |" << endl;
    }
    strm << "    ---" << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x14a4a(%rip), %rsi     # 0x2e2a2
movl $0x9, %edx
movq %rbx, %rdi
callq 0x6360
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x6360
movq %rax, %r15
leaq 0x149de(%rip), %rsi     # 0x2e25d
movl $0x7, %edx
movq %rax, %rdi
callq 0x6360
movl 0x28(%r14), %esi
movq %r15, %rdi
callq 0x6530
movq %rax, %r15
leaq 0x149c3(%rip), %rsi     # 0x2e265
movl $0xc, %edx
movq %rax, %rdi
callq 0x6360
movl 0x2c(%r14), %esi
movq %r15, %rdi
callq 0x6530
movq %rax, %r15
leaq 0x12778(%rip), %rsi     # 0x2c03d
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq %rax, %r15
leaq 0x1497b(%rip), %rsi     # 0x2e27e
movl $0x7, %edx
movq %rax, %rdi
callq 0x6360
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x38(%r14), %rax
movq 0x18(%rax), %r15
leaq 0x8(%rax), %rcx
cmpq %rcx, %r15
je 0x199de
leaq 0x14933(%rip), %r12     # 0x2e286
movl $0xa, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
movq 0x20(%r15), %r13
testq %r13, %r13
je 0x19984
movq %r13, %rdi
callq 0x6130
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x6360
jmp 0x1999b
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x6500
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq %r15, %rdi
callq 0x6370
movq %rax, %r15
movq 0x38(%r14), %rax
leaq 0x8(%rax), %rcx
cmpq %rcx, %r15
jne 0x19953
cmpq %rcx, 0x18(%rax)
jne 0x19a1f
leaq 0x148a6(%rip), %rsi     # 0x2e291
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
leaq 0x14858(%rip), %rsi     # 0x2e27e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x61f0
nop