LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x282fa(%rip), %rcx     # 0x3e780
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 %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 0x16c68
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63d0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x164f9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
xorl %eax, %eax
movq %rax, 0xa0(%rbx)
movq %rax, 0x10(%r14)
movq 0x8(%r14), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x16525
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %r14, %rdi
callq 0x6300
movl $0x1, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1655e
movq (%r12), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x16a62
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_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 0x281de(%rip), %rcx     # 0x3e7a8
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 %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 0x16c68
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63d0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x16644
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
xorl %eax, %eax
movq %rax, 0xa8(%rbx)
movq %rax, 0x10(%r14)
movq 0x8(%r14), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x16670
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %r14, %rdi
callq 0x6300
movl $0x1, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x166a9
movq (%r12), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x16a62
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/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 0x167e1
movq 0x40(%r14), %rbp
cmpb $0x1, 0x32(%rbp)
jne 0x167cd
cmpb $0x0, 0x31(%rbp)
jne 0x167cd
leaq 0x28ccf(%rip), %rax     # 0x3f408
movq (%rax), %r15
addq $0x48, %r15
movl $0x1c, %edx
movq %r15, %rdi
leaq 0x18a24(%rip), %rsi     # 0x2f173
callq 0x6370
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x17ff4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x6370
movl $0x2, %edx
movq %rax, %rdi
leaq 0x1be15(%rip), %rsi     # 0x32597
callq 0x6370
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x167a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
leaq 0x28c5e(%rip), %rax     # 0x3f408
movq (%rax), %r15
movq %rbp, %rdi
callq 0x1801e
movl %eax, %r12d
movq %rbp, %rdi
callq 0x18022
movq %r15, %rdi
movl %r12d, %esi
movl %eax, %edx
callq 0x1a874
movq %r14, %rdi
callq 0x6210
movq %rax, %r14
cmpq %r13, %rax
jne 0x1671a
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x16b20
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x16b15
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17e99
movl %esi, %edx
cvtsi2sd %edi, %xmm1
cvtsi2sd %esi, %xmm0
mulsd %xmm1, %xmm0
andpd 0x17396(%rip), %xmm0    # 0x2f210
testl %esi, %esi
je 0x17e90
movl %edi, %eax
movl %edx, %edi
cltd
idivl %edi
testl %edx, %edx
jne 0x17e7e
xorps %xmm1, %xmm1
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rax, %rcx
movb $0x0, 0xb(%rax)
testl %ebx, %ebx
jle 0x17ef7
xorl %edx, %edx
movl $0xcccccccd, %esi       # imm = 0xCCCCCCCD
movl %ebx, %edi
imulq %rsi, %rdi
shrq $0x23, %rdi
leal (%rdi,%rdi), %r8d
leal (%r8,%r8,4), %r8d
movl %ebx, %r9d
subl %r8d, %r9d
orb $0x30, %r9b
movb %r9b, 0xa(%rax,%rdx)
decq %rdx
cmpl $0x9, %ebx
movl %edi, %ebx
ja 0x17ebe
leal 0xa(%rdx), %esi
cmpl $0xa, %esi
ja 0x17f1a
addq $0xb, %rdx
jmp 0x17efc
movl $0xb, %edx
movl %edx, %edi
movl $0xc, %esi
subl %edx, %esi
addq %rdi, %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %dil
movb %dil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %rsi
jne 0x17f0a
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17268(%rip), %xmm0    # 0x2f220
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 0x18264
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x17feb
movq (%r13), %rsi
incq %rsi
callq 0x6300
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18115
movq 0x80(%rbx), %rsi
cmpq 0x88(%rbx), %rsi
je 0x18104
movl (%r12), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x80(%rbx)
jmp 0x1810f
movq %r15, %rdi
movq %r12, %rdx
callq 0x182b4
addq $0x4, %r12
jmp 0x180db
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18120
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1813a
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x1823c
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1893c
leaq 0x20(%r12), %rcx
cmpq %rcx, %rax
je 0x1843c
testq %rbx, %rbx
je 0x1841f
movl $0x0, (%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1861c
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 0x18497
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 0x16c68
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x183ea
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1848e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
testq %rbx, %rbx
je 0x1842d
incl (%rbx)
jmp 0x1842d
xorl %r14d, %r14d
jmp 0x1842d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x184b6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17ff4
movq %r15, %rdi
movq %r12, %rsi
callq 0x18698
movq %r14, (%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18531
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movl 0x3c(%r14), %edi
movl 0xc(%rbx), %ecx
testl %edi, %edi
jle 0x18577
movl %ecx, %eax
xorl %edx, %edx
divl %edi
movl %edi, %eax
subl %edx, %eax
xorl %edx, %edx
divl %edi
movl %edx, %esi
addl %ecx, %esi
movl %esi, 0x34(%r14)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movl %eax, 0x40(%r14)
movl %esi, %eax
xorl %edx, %edx
divl %edi
movl %edi, %eax
subl %edx, %eax
xorl %edx, %edx
divl %edi
addl 0x38(%r14), %esi
addl %edx, %esi
movl %esi, 0xc(%rbx)
jmp 0x18587
movl %ecx, 0x34(%r14)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movl %eax, 0x40(%r14)
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 0x185b1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/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 0x185db
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_O3/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 0x25d5e(%rip), %rax     # 0x3ebb8
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 0x25d1c(%rip), %rax     # 0x3eba0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x18e9b
movq (%r15), %rsi
incq %rsi
callq 0x6300
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25cf1(%rip), %rax     # 0x3ebd0
movq %rax, (%rbx)
callq 0x6180
movq %r14, 0x28(%rbx)
movq %r15, 0x30(%rbx)
movq 0x30(%r15), %r14
addq $0x20, %r15
cmpq %r15, %r14
je 0x18f6c
leaq 0x2650d(%rip), %r15     # 0x3f410
movq 0x40(%r14), %rdi
movl $0x0, 0x34(%rdi)
callq 0x1801a
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 0x1801a
cltq
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
movl 0x2c(%rax), %esi
movl %ebp, %edi
callq 0x17e5e
movl %eax, 0x2c(%rbx)
movq %r14, %rdi
callq 0x6210
movq %rax, %r14
movq 0x30(%rbx), %rax
addq $0x20, %rax
cmpq %rax, %r14
jne 0x18f03
movl 0x28(%rbx), %eax
addl $0x4, %eax
jmp 0x18f71
movl $0x4, %eax
movl %eax, 0x28(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18f7f
movq %rax, %r14
leaq 0x25c17(%rip), %rax     # 0x3eba0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq %r12, %rdi
je 0x18fa1
movq (%r12), %rsi
incq %rsi
callq 0x6300
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25c0d(%rip), %rax     # 0x3ebe8
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 0x19027
movq (%rax), %rsi
incq %rsi
callq 0x6300
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6300
movq %rax, %rbx
leaq 0x25b57(%rip), %rax     # 0x3eba0
movq %rax, (%r14)
movq 0x8(%r14), %rdi
cmpq %r12, %rdi
je 0x19061
movq (%r12), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25ba1(%rip), %rax     # 0x3ec58
movq %rax, (%rdi)
leaq 0x10(%rsp), %rdi
callq 0x6220
leaq 0x20(%rsp), %r13
leaq 0x16170(%rip), %rsi     # 0x2f240
movl $0x5, %edx
movq %r13, %rdi
callq 0x6370
leaq 0x1440c(%rip), %rsi     # 0x2d4f0
movl $0x1, %edx
movq %r13, %rdi
callq 0x6370
movq %r13, %rdi
movl %r15d, %esi
callq 0x6540
movq %rax, %r13
leaq 0x1458c(%rip), %rsi     # 0x2d692
movl $0x1, %edx
movq %rax, %rdi
callq 0x6370
movq %r13, %rdi
movl %r14d, %esi
callq 0x6540
movq %rax, %r13
leaq 0x1611e(%rip), %rsi     # 0x2f246
movl $0x5, %edx
movq %rax, %rdi
callq 0x6370
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r13, %rdi
callq 0x6370
leaq 0x8(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x63f0
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 0x25df5(%rip), %rsi     # 0x3ef88
leaq 0x10(%rsp), %rdi
callq 0x6250
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 0x191e2
movq %rax, %r14
movq 0x25dbd(%rip), %rsi     # 0x3ef88
leaq 0x10(%rsp), %rdi
callq 0x6250
leaq 0x90(%rsp), %rdi
callq 0x6100
leaq 0x259b7(%rip), %rax     # 0x3eba0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x19207
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6300
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25a23(%rip), %rax     # 0x3ec70
movq %rax, (%rdi)
movl %esi, 0x30(%rdi)
movq %rsp, %rdi
callq 0x6220
leaq 0x10(%rsp), %r15
leaq 0x15fe5(%rip), %rsi     # 0x2f24c
movl $0xb, %edx
movq %r15, %rdi
callq 0x6370
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x6370
leaq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x63f0
movabsq $0x400000004, %rax      # imm = 0x400000004
movq %rax, 0x28(%rbx)
movq 0x25ce4(%rip), %rsi     # 0x3ef88
movq %rsp, %rdi
callq 0x6250
leaq 0x80(%rsp), %rdi
callq 0x6100
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x192ec
movq %rax, %r14
movq 0x25cb1(%rip), %rsi     # 0x3ef88
movq %rsp, %rdi
callq 0x6250
leaq 0x80(%rsp), %rdi
callq 0x6100
leaq 0x258ad(%rip), %rax     # 0x3eba0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq %r12, %rdi
je 0x1930b
movq (%r12), %rsi
incq %rsi
callq 0x6300
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x159f6(%rip), %rsi     # 0x2f2a2
movl $0x9, %edx
movq %rbx, %rdi
callq 0x6370
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x6370
movq %rax, %r15
leaq 0x1598a(%rip), %rsi     # 0x2f25d
movl $0x7, %edx
movq %rax, %rdi
callq 0x6370
movl 0x28(%r14), %esi
movq %r15, %rdi
callq 0x6540
movq %rax, %r15
leaq 0x1596f(%rip), %rsi     # 0x2f265
movl $0xc, %edx
movq %rax, %rdi
callq 0x6370
movl 0x2c(%r14), %esi
movq %r15, %rdi
callq 0x6540
movq %rax, %r15
leaq 0x13724(%rip), %rsi     # 0x2d03d
movl $0x1, %edx
movq %rax, %rdi
callq 0x6370
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq %rax, %r15
leaq 0x15927(%rip), %rsi     # 0x2f27e
movl $0x7, %edx
movq %rax, %rdi
callq 0x6370
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq 0x38(%r14), %rax
movq 0x18(%rax), %r15
addq $0x8, %rax
cmpq %rax, %r15
je 0x19a38
leaq 0x158df(%rip), %r12     # 0x2f286
movl $0xa, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6370
movq 0x20(%r15), %r13
testq %r13, %r13
je 0x199d8
movq %r13, %rdi
callq 0x6130
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x6370
jmp 0x199ef
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x6510
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq %r15, %rdi
callq 0x6380
movq %rax, %r15
movq 0x38(%r14), %rax
leaq 0x8(%rax), %rcx
cmpq %rcx, %r15
jne 0x199a7
cmpq %r15, 0x18(%rax)
jne 0x19a73
leaq 0x15852(%rip), %rsi     # 0x2f291
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
leaq 0x15804(%rip), %rsi     # 0x2f27e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x6370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6200
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/type_table.cpp
// Function: type_table::add_type(type_descriptor*)
int type_table::add_type( type_descriptor* td ){

    map<string, int>::iterator i = names.find( td->name );
    if ( i == names.end() ){
        names[ td->name ] = types.size();
        types.push_back( td );
        
        return types.size()-1;
    }
    
    return (*i).second;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x18(%rdi), %r15
leaq 0x8(%rsi), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a3dc
leaq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x19ff1
movl 0x40(%rax), %eax
jmp 0x1a03f
movq 0x8(%rbx), %r13
subq (%rbx), %r13
shrq $0x3, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a360
movl %r13d, (%rax)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1a025
movq %r14, (%rsi)
movq 0x8(%rbx), %rax
addq $0x8, %rax
movq %rax, 0x8(%rbx)
jmp 0x1a036
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a536
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
decl %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/type_table.cpp
// Function: type_table::dump(std::ostream&)
void type_table::dump(ostream &strm) {
    strm << " TYPES:" << endl;
    vector<type_descriptor*>::iterator it;
    for (it=types.begin(); it != types.end(); ++it){
        (*it)->dump(strm);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x14ff8(%rip), %rsi     # 0x2f304
movl $0x7, %edx
movq %rbx, %rdi
callq 0x6370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x1a35a
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r15
jmp 0x1a343
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/llog.cpp
// Function: llog::warning(int, int)
void llog::warning(int l, int c){
    string b = buf.str();
    buf.str("");
    buf << "Warning " << l << ":" << c << ": "<< b;
    messages[l][c].push_back(buf.str());
    buf.str("");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
leaq 0x50(%rdi), %rbx
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x64b0
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x14acf(%rip), %rdx     # 0x2f382
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x7008
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6460
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1a8df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
leaq 0x48(%r14), %r12
leaq 0x14a22(%rip), %rsi     # 0x2f30c
movl $0x8, %edx
movq %r12, %rdi
callq 0x6370
movq %r12, %rdi
movl %r15d, %esi
callq 0x6540
movq %rax, %r15
leaq 0x149fe(%rip), %rsi     # 0x2f30a
movl $0x1, %edx
movq %rax, %rdi
callq 0x6370
movq %r15, %rdi
movl %ebp, %esi
callq 0x6540
movq %rax, %r15
leaq 0x12d8a(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x6370
leaq 0x24(%rsp), %rsi
movq %r14, %rdi
callq 0x1acd6
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1ad3c
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x64b0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1b2fe
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1a995
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x149e0(%rip), %rdx     # 0x2f382
movq %rdx, %rsi
callq 0x7008
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6460
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1a9cb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a9e6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a9fd
jmp 0x1aa1a
jmp 0x1a9fd
jmp 0x1aa1a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1aa1d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x1aa1d
jmp 0x1aa1a
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1aa38
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/llog.cpp
// Function: llog::error(int, int)
void llog::error(int l, int c){
    string b = buf.str();
    buf.str("");
    if (b.compare("parse error")) {
        buf << "Error   " << l << ":" << c << ": "<< b;
        messages[l][c].push_back(buf.str());
        buf.str("");
    }
    registered_error = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
leaq 0x50(%rdi), %r14
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x64b0
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x14903(%rip), %rdx     # 0x2f382
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x7008
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6460
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1aaab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
leaq 0x14863(%rip), %rsi     # 0x2f315
leaq 0x28(%rsp), %rdi
callq 0x60d0
testl %eax, %eax
je 0x1abb0
leaq 0x48(%rbx), %r12
leaq 0x14852(%rip), %rsi     # 0x2f321
movl $0x8, %edx
movq %r12, %rdi
callq 0x6370
movq %r12, %rdi
movl %r15d, %esi
callq 0x6540
movq %rax, %r15
leaq 0x14819(%rip), %rsi     # 0x2f30a
movl $0x1, %edx
movq %rax, %rdi
callq 0x6370
movq %r15, %rdi
movl %ebp, %esi
callq 0x6540
movq %rax, %r15
leaq 0x12ba5(%rip), %rsi     # 0x2d6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6370
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x6370
leaq 0x24(%rsp), %rsi
movq %rbx, %rdi
callq 0x1acd6
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1ad3c
movq %rax, %r15
movq %rsp, %rdi
movq %r14, %rsi
callq 0x64b0
movq %rsp, %rsi
movq %r15, %rdi
callq 0x1b2fe
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ab7a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x147fb(%rip), %rdx     # 0x2f382
movq %rdx, %rsi
callq 0x7008
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6460
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1abb0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
movb $0x1, 0x30(%rbx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1abcf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1abe6
jmp 0x1ac03
jmp 0x1abe6
jmp 0x1ac03
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ac06
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x1ac06
jmp 0x1ac03
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ac21
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/block.cpp
// Function: Block::Block(bool)
Block::Block(bool with_vector){
    w_vector = with_vector;
    if ( with_vector ){
        instructions.vinst = new vector<inst*>();
    } else {
        instructions.linst = new list<inst*>();
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
movb %bpl, 0x4(%rdi)
movl $0x18, %edi
callq 0x62f0
testl %ebp, %ebp
je 0x1b5a1
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
jmp 0x1b5a8
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/block.cpp
// Function: Block::append_inst(inst*, bool)
void Block::append_inst(inst *i, bool gen_label) {

    int ninst = next_instruction();
    if ( w_vector ){
        instructions.vinst->push_back(i);
        
        if ( gen_label ){
            instructions.vinst->back()->label = ninst;
        }
    } else {
        instructions.linst->push_back(i);
        
        if ( gen_label ){
            instructions.linst->back()->label = ninst;
        }
    }
    
    if ( gen_label ){
        next_label++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movl 0x23da8(%rip), %r12d    # 0x3f384
movq 0x8(%rdi), %r14
cmpb $0x1, 0x4(%rdi)
jne 0x1b5fa
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x1b61e
movq %r15, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x1b62b
movl $0x18, %edi
callq 0x62f0
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x6080
incq 0x10(%r14)
movl $0x10, %eax
jmp 0x1b632
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x1caea
movq $-0x8, %rax
testb %bpl, %bpl
je 0x1b64d
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx,%rax), %rax
movl %r12d, 0x8(%rax)
incl 0x23d37(%rip)           # 0x3f384
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/block.cpp
// Function: Block::dump(std::ostream&, bool)
void Block::dump(ostream &strm, bool with_comments) {
    if ( w_vector ){
        vector<inst*>::iterator it = instructions.vinst->begin();
        for (; it != instructions.vinst->end(); ++ it) {
            strm << ((inst*)(*it))->to_string(with_comments) << endl;
        }
    } else {
        list<inst*>::iterator it = instructions.linst->begin();
        for (; it != instructions.linst->end(); ++ it) {
            strm << ((inst*)(*it))->to_string(with_comments) << endl;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq (%rax), %r13
cmpb $0x1, 0x4(%rdi)
jne 0x1b731
cmpq 0x8(%rax), %r13
je 0x1b7ae
movzbl %dl, %ebp
leaq 0x8(%rsp), %r15
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
movl %ebp, %edx
callq *(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x6370
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1b721
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
addq $0x8, %r13
movq 0x8(%r14), %rax
cmpq 0x8(%rax), %r13
jne 0x1b6bb
jmp 0x1b7ae
cmpq %rax, %r13
je 0x1b7ae
movzbl %dl, %ebp
leaq 0x8(%rsp), %r15
movq 0x10(%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
movl %ebp, %edx
callq *(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x6370
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6200
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1b7a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq (%r13), %r13
cmpq 0x8(%r14), %r13
jne 0x1b73e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b7bf
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1b7de
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/block.cpp
// Function: Block::max_label()
unsigned int Block::max_label(){
    
    unsigned int maxl = 0;
    
    if ( w_vector ){
        
        unsigned int nsize = instructions.vinst->size();
        for (unsigned int i=0; i<nsize; i++){
            inst* current_inst = (*(instructions.vinst))[i];
            maxl = max(maxl, current_inst->label);
        }
        
    } else {
        
        list<inst*>::iterator it = instructions.linst->begin();
        for( ; it != instructions.linst->end(); ++it){
            inst* current_inst = *it;
            maxl = max(maxl, current_inst->label);
        }
    }
    
    return maxl;
}

// Assembly:
movq 0x8(%rdi), %rdx
cmpb $0x1, 0x4(%rdi)
jne 0x1b81e
movq (%rdx), %rcx
movq 0x8(%rdx), %rax
subq %rcx, %rax
shrq $0x3, %rax
testl %eax, %eax
je 0x1b840
movl %eax, %edx
xorl %esi, %esi
xorl %eax, %eax
movq (%rcx,%rsi,8), %rdi
movl 0x8(%rdi), %edi
cmpl %edi, %eax
cmovbel %edi, %eax
incq %rsi
cmpq %rsi, %rdx
jne 0x1b808
jmp 0x1b83f
movq (%rdx), %rcx
cmpq %rdx, %rcx
je 0x1b840
xorl %eax, %eax
movq 0x10(%rcx), %rsi
movl 0x8(%rsi), %esi
cmpl %esi, %eax
cmovbel %esi, %eax
movq (%rcx), %rsi
movq %rsi, %rcx
cmpq %rdx, %rsi
jne 0x1b828
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: opd::opd(int, char)
opd::opd(int s, char type){

    data.pint = s;
    this->type = type;
    switch (type) {
        case O_LABEL: case O_INT:
            data.pint = s;
            break;
        case O_SL:
            data.spim.lab = s;
            break;
        case O_SI:
            data.spim.imm = s;
            break;
        default:
            throw string("") + "Error de implementaci�n, tipo " + itoa_(type) + " de instrucci�n desconocido";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r14d
movl %esi, (%rdi)
movb %r14b, 0x10(%rdi)
leal -0x2(%r14), %eax
rorl %eax
cmpl $0x7, %eax
ja 0x1d072
leaq 0x12471(%rip), %rcx     # 0x2f4c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %esi, (%rdi)
jmp 0x1d063
movl %esi, 0x4(%rdi)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6150
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x122f3(%rip), %rdx     # 0x2f382
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x7008
leaq 0x12574(%rip), %rsi     # 0x2f617
leaq 0x8(%rsp), %rdi
callq 0x65b0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1d0d0
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x1d0dd
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl %r14d, %edi
callq 0x17e9f
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x65b0
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1d12c
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x1d139
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
leaq 0x124d7(%rip), %rdx     # 0x2f636
movq %rbx, %rdi
callq 0x21fab
xorl %ebp, %ebp
leaq 0x21b38(%rip), %rsi     # 0x3eca8
movq 0x21e21(%rip), %rdx     # 0x3ef98
movq %rbx, %rdi
callq 0x6530
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d1a1
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x1d1a1
movq %rax, %r14
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1d1b8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d1cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
testb %bpl, %bpl
jne 0x1d1f5
jmp 0x1d1fd
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d1f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x1d1f5
movq %rax, %r14
movq %rbx, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: opd::opd(int, int, char)
opd::opd(int s1, int s2, char type){

    this->type = type;
    switch (type) {
        case O_SLI:
            data.spim.lab = s1;
            data.spim.imm = s2;
            break;
        case O_SLR:
            data.spim.lab = s1;
            data.spim.reg = s2;
            break;
        case O_SIR:
            data.spim.imm = s1;
            data.spim.reg = s2;
            break;
        default:
            throw string("") + "Error de implementaci�n, tipo " + itoa_(type) + " de instrucci�n desconocido";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movb %bpl, 0x10(%rdi)
cmpl $0x30, %ecx
je 0x1d234
cmpl $0x28, %ebp
je 0x1d230
cmpl $0x18, %ebp
jne 0x1d249
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
jmp 0x1d23a
movl %esi, (%rdi)
jmp 0x1d237
movl %esi, 0x4(%rdi)
movl %edx, 0x8(%rdi)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6150
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1211c(%rip), %rdx     # 0x2f382
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x7008
leaq 0x1239d(%rip), %rsi     # 0x2f617
leaq 0x8(%rsp), %rdi
callq 0x65b0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1d2a7
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x1d2b4
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl %ebp, %edi
callq 0x17e9f
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x65b0
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1d302
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x1d30f
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
leaq 0x12301(%rip), %rdx     # 0x2f636
movq %rbx, %rdi
callq 0x21fab
xorl %ebp, %ebp
leaq 0x21962(%rip), %rsi     # 0x3eca8
movq 0x21c4b(%rip), %rdx     # 0x3ef98
movq %rbx, %rdi
callq 0x6530
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d377
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x1d377
movq %rax, %r14
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1d38e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6300
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d3a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
testb %bpl, %bpl
jne 0x1d3cb
jmp 0x1d3d3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d3cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6300
jmp 0x1d3cb
movq %rax, %r14
movq %rbx, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: inst::get_goal_label()
unsigned int inst::get_goal_label(){
    assert (op == GOTO);
    if (0 != arg2) {
        return arg2->data.pint;
    } else {
        return -1;
    }
}

// Assembly:
cmpl $0x16, 0xc(%rdi)
jne 0x1da94
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x1da8e
movl (%rax), %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
pushq %rax
leaq 0x11bc8(%rip), %rdi     # 0x2f664
leaq 0x11bcc(%rip), %rsi     # 0x2f66f
leaq 0x11bd2(%rip), %rcx     # 0x2f67c
movl $0x79, %edx
callq 0x61d0
// File: /workspace/github_cpp_makefile_star2_O3/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: inst::mandatory_jump()
bool inst::mandatory_jump(){
    assert(is_jump());
    switch ( op ){
        case GOTO:
//        case CALL:
        case RETURN:
        case EPILOGUE:
            return true;
        default:
            return false;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x1daea
movl 0xc(%rbx), %ecx
cmpl $0x17, %ecx
setb %dl
movl $0x418000, %eax         # imm = 0x418000
shrl %cl, %eax
andb %dl, %al
popq %rbx
retq
leaq 0x11baf(%rip), %rdi     # 0x2f6a0
leaq 0x11b77(%rip), %rsi     # 0x2f66f
leaq 0x11bab(%rip), %rcx     # 0x2f6aa
movl $0x95, %edx
callq 0x61d0
nop