LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
callq 0x13e3c
leaq 0x78(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
andq $0x0, 0x88(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6170
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)
orq $-0x1, 0x3c(%rbx)
movq (%r15), %r12
cmpq 0x8(%r15), %r12
je 0x13fad
movq %r14, %rdi
movq %r12, %rsi
callq 0x14082
addq $0x4, %r12
jmp 0x13f96
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13fbe
movq %rax, %r15
movq %r14, %rdi
callq 0x13aba
movq %rbx, %rdi
callq 0x140a0
movq %r15, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14730
leaq 0x20(%r12), %rcx
cmpq %rcx, %rax
je 0x1427d
testq %rbx, %rbx
je 0x14260
andl $0x0, (%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x143d8
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 0x142ba
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x63e0
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1422e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x65c8
testq %rbx, %rbx
je 0x1426e
incl (%rbx)
jmp 0x1426e
xorl %r14d, %r14d
jmp 0x1426e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13efa
movq %r15, %rdi
movq %r12, %rsi
callq 0x1445a
movq %r14, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x65c8
movl 0x3c(%r14), %esi
movl 0xc(%rbx), %ecx
testl %esi, %esi
jle 0x1433e
movl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %esi, %eax
subl %edx, %eax
xorl %edx, %edx
divl %esi
addl %edx, %ecx
movl %ecx, 0xc(%rbx)
movl %ecx, 0x34(%r14)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movl %eax, 0x40(%r14)
testl %esi, %esi
jle 0x14369
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 0x8(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/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 0x143ab
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x28(%rbx)
leaq 0x22f5c(%rip), %rax     # 0x37bf8
movq %rax, (%rbx)
callq 0x6170
movl 0xc(%r14), %eax
movl %eax, 0x28(%rbx)
movl $0x4, 0x2c(%rbx)
movq %r14, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x122a6
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x8, %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movabsq $0x100000000, %r14      # imm = 0x100000000
movq %r14, 0x28(%rbx)
leaq 0x22f06(%rip), %rax     # 0x37c10
movq %rax, (%rbx)
callq 0x6170
movq %r14, 0x28(%rbx)
movq %r15, 0x30(%rbx)
movq 0x30(%r15), %r14
leaq 0x236e3(%rip), %r12     # 0x38408
addq $0x20, %r15
cmpq %r15, %r14
je 0x14d87
movq 0x40(%r14), %rdi
andl $0x0, 0x34(%rdi)
callq 0x13f0c
cltq
movq (%r12), %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 0x13f0c
cltq
movq (%r12), %rcx
movq (%rcx,%rax,8), %rax
movl 0x2c(%rax), %esi
movl %ebp, %edi
callq 0x13da0
movl %eax, 0x2c(%rbx)
movq %r14, %rdi
callq 0x61f0
movq %rax, %r14
movq 0x30(%rbx), %r15
jmp 0x14d25
addl $0x4, 0x28(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14d96
movq %rax, %r14
movq %rbx, %rdi
callq 0x122a6
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
andq $0x0, 0x10(%r14)
movb $0x0, 0x18(%r14)
leaq 0x22e53(%rip), %rax     # 0x37c28
movq %rax, (%r14)
movabsq $0x400000004, %rax      # imm = 0x400000004
movq %rax, 0x28(%r14)
movq (%rsi), %rax
movq %rax, 0x30(%r14)
addq $0x8, %rsi
callq 0x6170
movq %r15, 0x38(%r14)
movq %rbx, %rdi
callq 0x125aa
pushq $0x28
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x62e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x122a6
movq %rbx, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %r8d, %r15d
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x28(%rdi)
leaq 0x22e2f(%rip), %rax     # 0x37c98
movq %rax, (%rdi)
leaq 0x8(%rsp), %rdi
callq 0x6200
leaq 0x18(%rsp), %rdi
leaq 0x103ae(%rip), %rsi     # 0x25230
callq 0x62b0
leaq 0xe662(%rip), %rsi      # 0x234f0
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
movl %r15d, %esi
callq 0x6510
leaq 0xe7ea(%rip), %rsi      # 0x23692
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
movl %r14d, %esi
callq 0x6510
leaq 0x10374(%rip), %rsi     # 0x25236
movq %rax, %rdi
callq 0x62b0
leaq 0x8(%r12), %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x63b0
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)
leaq 0x8(%rsp), %rdi
callq 0x6240
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x14f48
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6240
movq %rbx, %rdi
callq 0x122a6
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rdx, %r14
movb $0x0, 0x18(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x28(%rdi)
leaq 0x22d22(%rip), %rax     # 0x37cb0
movq %rax, (%rdi)
movl %esi, 0x30(%rdi)
movq %rsp, %rdi
callq 0x6200
leaq 0x10(%rsp), %rdi
leaq 0x10294(%rip), %rsi     # 0x2523c
callq 0x62b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x62a0
leaq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x63b0
movabsq $0x400000004, %rax      # imm = 0x400000004
movq %rax, 0x28(%rbx)
movq %rsp, %rdi
callq 0x6240
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %r14
jmp 0x14ff5
movq %rax, %r14
movq %rsp, %rdi
callq 0x6240
movq %rbx, %rdi
callq 0x122a6
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/type_descriptor.cpp
// Function: struct_type::dump(std::ostream&)
void struct_type::dump(ostream &strm){
    strm << "  * struct " << name << " [size " << width
         << "][alignment " << alignment << "]" << endl
         << "    ---" << endl;
    map<string, symbol*>::iterator it;
    for (it = fields->table.begin(); it != fields->table.end(); ++it){
        strm << "    |   - " << types.types[(*it).second->getType()]->name
             << ' ' << (*it).first << " [offset " << (*it).second->offset << ']' << endl;
    }
    if ( fields->table.begin() == fields->table.end() ){
        strm << "    |" << endl;
    }
    strm << "    ---" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x101d6(%rip), %rsi     # 0x25262
movq %rbx, %rdi
callq 0x62b0
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x101a6(%rip), %rsi     # 0x2524d
movq %rax, %rdi
callq 0x62b0
movl 0x28(%r14), %esi
movq %rax, %rdi
callq 0x6510
leaq 0x10193(%rip), %rsi     # 0x25255
movq %rax, %rdi
callq 0x62b0
movl 0x2c(%r14), %esi
movq %rax, %rdi
callq 0x6510
leaq 0xdf60(%rip), %rsi      # 0x2303d
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
leaq 0x1017a(%rip), %rsi     # 0x2526e
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
movq 0x30(%r14), %rax
movq 0x30(%rax), %r12
pushq $0x5d
popq %r15
leaq 0x20(%rax), %rcx
cmpq %rcx, %r12
je 0x151b6
movq %rbx, %rdi
leaq 0x1014f(%rip), %rsi     # 0x25276
callq 0x62b0
movq %rax, %rbp
leaq 0x20(%r12), %r13
movq 0x40(%r12), %rdi
callq 0x13f0c
cltq
leaq 0x232c1(%rip), %rcx     # 0x38408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rsi
addq $0x8, %rsi
movq %rbp, %rdi
callq 0x62a0
movq %rax, %rdi
pushq $0x20
popq %rsi
callq 0x6350
movq %rax, %rdi
movq %r13, %rsi
callq 0x62a0
movq %rax, %rdi
leaq 0xe328(%rip), %rsi      # 0x234a2
callq 0x62b0
movq 0x40(%r12), %rcx
movl 0x34(%rcx), %esi
movq %rax, %rdi
callq 0x61e0
movq %rax, %rdi
movl %r15d, %esi
callq 0x6350
movq %rax, %rdi
callq 0x6130
movq %r12, %rdi
callq 0x61f0
movq %rax, %r12
movq 0x30(%r14), %rax
jmp 0x15110
cmpq %r12, 0x30(%rax)
jne 0x151d3
leaq 0x100be(%rip), %rsi     # 0x25281
movq %rbx, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
leaq 0x10094(%rip), %rsi     # 0x2526e
movq %rbx, %rdi
callq 0x62b0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6130
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/type_descriptor.cpp
// Function: union_type::dump(std::ostream&)
void union_type::dump(ostream &strm){
    strm << "  * union " << name << " [size " << width
         << "][alignment " << alignment << "]" << endl
         << "    ---" << endl;
    map<string, symbol*>::iterator it;
    for (it = fields->table.begin(); it != fields->table.end(); ++it){
        strm << "    |   - " << types.types[(*it).second->getType()]->name
             << ' ' << (*it).first << endl;
    }
    if ( fields->table.begin() == fields->table.end() ){
        strm << "    |" << endl;
    }
    strm << "    ---" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10077(%rip), %rsi     # 0x25287
movq %rbx, %rdi
callq 0x62b0
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x10022(%rip), %rsi     # 0x2524d
movq %rax, %rdi
callq 0x62b0
movl 0x28(%r14), %esi
movq %rax, %rdi
callq 0x6510
leaq 0x1000f(%rip), %rsi     # 0x25255
movq %rax, %rdi
callq 0x62b0
movl 0x2c(%r14), %esi
movq %rax, %rdi
callq 0x6510
leaq 0xdddc(%rip), %rsi      # 0x2303d
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
leaq 0xfff6(%rip), %rsi      # 0x2526e
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
movq 0x30(%r14), %rax
movq 0x30(%rax), %r12
pushq $0x20
popq %rbp
leaq 0x20(%rax), %rcx
cmpq %rcx, %r12
je 0x15307
movq %rbx, %rdi
leaq 0xffd0(%rip), %rsi      # 0x25276
callq 0x62b0
movq %rax, %r13
leaq 0x20(%r12), %r15
movq 0x40(%r12), %rdi
callq 0x13f0c
cltq
leaq 0x23142(%rip), %rcx     # 0x38408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rsi
addq $0x8, %rsi
movq %r13, %rdi
callq 0x62a0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6350
movq %rax, %rdi
movq %r15, %rsi
callq 0x62a0
movq %rax, %rdi
callq 0x6130
movq %r12, %rdi
callq 0x61f0
movq %rax, %r12
movq 0x30(%r14), %rax
jmp 0x15293
cmpq %r12, 0x30(%rax)
jne 0x15324
leaq 0xff6d(%rip), %rsi      # 0x25281
movq %rbx, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
leaq 0xff43(%rip), %rsi      # 0x2526e
movq %rbx, %rdi
callq 0x62b0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6130
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xff33(%rip), %rsi      # 0x25292
movq %rbx, %rdi
callq 0x62b0
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0xfed3(%rip), %rsi      # 0x2524d
movq %rax, %rdi
callq 0x62b0
movl 0x28(%r14), %esi
movq %rax, %rdi
callq 0x6510
leaq 0xfec0(%rip), %rsi      # 0x25255
movq %rax, %rdi
callq 0x62b0
movl 0x2c(%r14), %esi
movq %rax, %rdi
callq 0x6510
leaq 0xdc8d(%rip), %rsi      # 0x2303d
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
leaq 0xfea7(%rip), %rsi      # 0x2526e
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
movq 0x38(%r14), %rax
movq 0x18(%rax), %r12
leaq 0xfe90(%rip), %r15      # 0x25276
leaq 0x8(%rax), %rcx
cmpq %rcx, %r12
je 0x15420
movq %rbx, %rdi
movq %r15, %rsi
callq 0x62b0
movq 0x20(%r12), %rsi
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
movq %r12, %rdi
callq 0x6330
movq %rax, %r12
movq 0x38(%r14), %rax
jmp 0x153e6
cmpq %r12, 0x18(%rax)
jne 0x1543d
leaq 0xfe54(%rip), %rsi      # 0x25281
movq %rbx, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
leaq 0xfe2a(%rip), %rsi      # 0x2526e
movq %rbx, %rdi
callq 0x62b0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6130
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0x18(%rdi), %r15
addq $0x8, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x15b50
leaq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x15803
movl 0x40(%rax), %eax
jmp 0x15834
movq 0x8(%rbx), %r12
subq (%rbx), %r12
shrq $0x3, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x15a98
movl %r12d, (%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x15afe
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf88c(%rip), %rsi      # 0x252f4
movq %rbx, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6130
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x15a92
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r15
jmp 0x15a7b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
leaq 0x50(%rdi), %rbx
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x6480
leaq 0xf388(%rip), %rsi      # 0x25372
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
leaq 0x18(%rsp), %rdi
callq 0x65c8
leaq 0x48(%r14), %rdi
leaq 0xf2e1(%rip), %rsi      # 0x252fc
callq 0x62b0
movq %rax, %rdi
movl %r15d, %esi
callq 0x6510
leaq 0xf2c8(%rip), %rsi      # 0x252fa
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6510
leaq 0xd66c(%rip), %rsi      # 0x236b7
movq %rax, %rdi
callq 0x62b0
leaq 0x38(%rsp), %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x14(%rsp), %rsi
movq %r14, %rdi
callq 0x16306
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x16354
movq %rax, %r14
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x6480
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x169d6
leaq 0x18(%rsp), %rdi
callq 0x65c8
leaq 0xf2ca(%rip), %rsi      # 0x25372
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
leaq 0x18(%rsp), %rdi
callq 0x65c8
leaq 0x38(%rsp), %rdi
callq 0x65c8
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x160eb
jmp 0x160fc
jmp 0x160eb
jmp 0x160fc
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x65c8
jmp 0x160ff
jmp 0x160fc
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/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 %rbx
subq $0x58, %rsp
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
leaq 0x50(%rdi), %r14
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x6480
leaq 0xf22e(%rip), %rsi      # 0x25372
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x6440
leaq 0x18(%rsp), %rdi
callq 0x65c8
leaq 0xf194(%rip), %rsi      # 0x25305
leaq 0x38(%rsp), %rdi
callq 0x60d0
testl %eax, %eax
je 0x16241
leaq 0x48(%rbx), %rdi
leaq 0xf183(%rip), %rsi      # 0x25311
callq 0x62b0
movq %rax, %rdi
movl %r15d, %esi
callq 0x6510
leaq 0xf155(%rip), %rsi      # 0x252fa
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6510
leaq 0xd4f9(%rip), %rsi      # 0x236b7
movq %rax, %rdi
callq 0x62b0
leaq 0x38(%rsp), %rsi
movq %rax, %rdi
callq 0x62a0
leaq 0x14(%rsp), %rsi
movq %rbx, %rdi
callq 0x16306
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x16354
movq %rax, %r15
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x6480
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x169d6
leaq 0x18(%rsp), %rdi
callq 0x65c8
leaq 0xf157(%rip), %rsi      # 0x25372
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x6440
leaq 0x18(%rsp), %rdi
callq 0x65c8
movb $0x1, 0x30(%rbx)
leaq 0x38(%rsp), %rdi
callq 0x65c8
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16262
jmp 0x16273
jmp 0x16262
jmp 0x16273
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x65c8
jmp 0x16276
jmp 0x16273
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/llog.cpp
// Function: llog::dump(std::ostream&)
void llog::dump(ostream &errd)
{
    map<int, map<int, vector<string> > >::iterator itl;
    for (itl = messages.begin(); itl != messages.end(); ++ itl) {
        map<int, vector<string> >::iterator itc;
        for (itc = (*itl).second.begin(); itc != (*itl).second.end(); ++ itc) {
            vector<string>::iterator itm;
            for (itm = (*itc).second.begin(); itm != (*itc).second.end(); ++ itm) {
                errd << *itm << endl;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x162f6
movq 0x40(%r15), %r12
leaq 0x30(%r15), %rbp
cmpq %rbp, %r12
je 0x162e9
movq 0x28(%r12), %r13
cmpq 0x30(%r12), %r13
je 0x162dc
movq %rbx, %rdi
movq %r13, %rsi
callq 0x62a0
movq %rax, %rdi
callq 0x6130
addq $0x20, %r13
jmp 0x162bc
movq %r12, %rdi
callq 0x61f0
movq %rax, %r12
jmp 0x162b2
movq %r15, %rdi
callq 0x61f0
movq %rax, %r15
jmp 0x162a5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
andq $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movb %sil, 0x4(%rdi)
testl %esi, %esi
je 0x16bcf
pushq $0x18
popq %rdi
callq 0x62d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
jmp 0x16bde
pushq $0x18
popq %rdi
callq 0x62d0
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x17aa2
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movl 0x21761(%rip), %r14d    # 0x3837c
movq 0x8(%rdi), %rdi
cmpb $0x1, 0x4(%rbx)
jne 0x16c38
leaq 0x8(%rsp), %rsi
callq 0x178d0
testb %bpl, %bpl
je 0x16c60
pushq $-0x8
jmp 0x16c49
leaq 0x8(%rsp), %rsi
callq 0x178ee
testb %bpl, %bpl
je 0x16c60
pushq $0x10
popq %rax
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx,%rax), %rax
movl %r14d, 0x8(%rax)
incl 0x2171c(%rip)           # 0x3837c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpb $0x0, 0x4(%rdi)
je 0x16cec
movq (%rax), %r12
movzbl %dl, %ebp
movq %rsp, %r15
cmpq 0x8(%rax), %r12
je 0x16d2e
movq (%r12), %rsi
movq (%rsi), %rax
movq %r15, %rdi
movl %ebp, %edx
callq *(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x62a0
movq %rax, %rdi
callq 0x6130
movq %r15, %rdi
callq 0x65c8
addq $0x8, %r12
movq 0x8(%r14), %rax
jmp 0x16cb3
movzbl %dl, %ebp
movq %rsp, %r15
movq %rax, %r12
movq (%r12), %r12
cmpq %rax, %r12
je 0x16d2e
movq 0x10(%r12), %rsi
movq (%rsi), %rax
movq %r15, %rdi
movl %ebp, %edx
callq *(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x62a0
movq %rax, %rdi
callq 0x6130
movq %r15, %rdi
callq 0x65c8
movq 0x8(%r14), %rax
jmp 0x16cf5
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16d3d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x0, 0x4(%rdi)
je 0x16d84
movq (%rdx), %rcx
movq 0x8(%rdx), %rax
subq %rcx, %rax
shrq $0x3, %rax
movl %eax, %edx
xorl %esi, %esi
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x16d9f
movq (%rcx,%rsi,8), %rdi
movl 0x8(%rdi), %edi
cmpl %edi, %eax
cmovbel %edi, %eax
incq %rsi
jmp 0x16d6e
xorl %eax, %eax
movq %rdx, %rcx
movq (%rcx), %rcx
cmpq %rdx, %rcx
je 0x16d9f
movq 0x10(%rcx), %rsi
movl 0x8(%rsi), %esi
cmpl %esi, %eax
cmovbel %esi, %eax
jmp 0x16d89
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x70, %rsp
movl %edx, %r14d
movl %esi, (%rdi)
movb %r14b, 0x10(%rdi)
leal -0x2(%r14), %eax
rorl %eax
cmpl $0x7, %eax
ja 0x1819a
leaq 0xd333(%rip), %rcx      # 0x254b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %esi, (%rdi)
jmp 0x18191
movl %esi, 0x4(%rdi)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0xd1c6(%rip), %rsi      # 0x25372
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
leaq 0xd445(%rip), %rdx      # 0x25607
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x12447
movl %r14d, %edi
callq 0x13dda
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0x12447
movb $0x1, %bpl
leaq 0xd431(%rip), %rdx      # 0x25626
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x12447
xorl %ebp, %ebp
leaq 0x1faad(%rip), %rsi     # 0x37cb8
movq 0x1fd8e(%rip), %rdx     # 0x37fa0
movq %rbx, %rdi
callq 0x6500
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x65c8
jmp 0x1822f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x65c8
jmp 0x18241
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x65c8
testb %bpl, %bpl
jne 0x18255
jmp 0x1825d
movq %rax, %r14
movq %rbx, %rdi
callq 0x6220
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x70, %rsp
movl %ecx, %ebp
movb %bpl, 0x10(%rdi)
cmpl $0x30, %ecx
je 0x1828e
cmpl $0x28, %ebp
je 0x1828a
cmpl $0x18, %ebp
jne 0x1829d
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
jmp 0x18294
movl %esi, (%rdi)
jmp 0x18291
movl %esi, 0x4(%rdi)
movl %edx, 0x8(%rdi)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0xd0c3(%rip), %rsi      # 0x25372
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
leaq 0xd342(%rip), %rdx      # 0x25607
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x12447
movl %ebp, %edi
callq 0x13dda
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0x12447
movb $0x1, %bpl
leaq 0xd32f(%rip), %rdx      # 0x25626
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x12447
xorl %ebp, %ebp
leaq 0x1f9ab(%rip), %rsi     # 0x37cb8
movq 0x1fc8c(%rip), %rdx     # 0x37fa0
movq %rbx, %rdi
callq 0x6500
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x65c8
jmp 0x18331
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x65c8
jmp 0x18343
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x65c8
testb %bpl, %bpl
jne 0x18357
jmp 0x1835f
movq %rax, %r14
movq %rbx, %rdi
callq 0x6220
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x187ce
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x187ca
movl (%rax), %eax
retq
pushq $-0x1
popq %rax
retq
pushq %rax
leaq 0xce7e(%rip), %rdi      # 0x25654
leaq 0xce82(%rip), %rsi      # 0x2565f
leaq 0xce88(%rip), %rcx      # 0x2566c
pushq $0x79
popq %rdx
callq 0x61c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18822
movl 0xc(%rbx), %ecx
cmpl $0x17, %ecx
setb %dl
movl $0x418000, %eax         # imm = 0x418000
shrl %cl, %eax
andb %dl, %al
popq %rbx
retq
leaq 0xce67(%rip), %rdi      # 0x25690
leaq 0xce2f(%rip), %rsi      # 0x2565f
leaq 0xce63(%rip), %rcx      # 0x2569a
movl $0x95, %edx
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: quad::quad(inst::OP, opd*, opd*, opd*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
quad::quad(OP op, opd *arg0, opd *arg1, opd *arg2, string comment){
    this->op = op;
    this->arg0 = arg0;
    this->arg1 = arg1;
    this->arg2 = arg2;
    if (comment.compare("")) {
        comment = "# " + comment + "\n";
    }
    this->comment = comment;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %r9, %r14
movq %rdi, %rbx
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
leaq 0x1f46f(%rip), %rax     # 0x37cd8
movq %rax, (%rdi)
movl %esi, 0xc(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
leaq 0xcaf0(%rip), %rsi      # 0x25372
movq %r9, %rdi
callq 0x60d0
testl %eax, %eax
je 0x188d4
leaq 0xce29(%rip), %rsi      # 0x256be
movq %rsp, %rdi
movq %r14, %rdx
callq 0x179d3
leaq 0xcaca(%rip), %rdx      # 0x25371
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x12447
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6390
movq %r15, %rdi
callq 0x65c8
movq %rsp, %rdi
callq 0x65c8
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x6170
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x65c8
jmp 0x188fc
jmp 0x188f9
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a20c
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/inst.cpp
// Function: Spim_Inst::to_string[abi:cxx11](bool)
string Spim_Inst::to_string(bool with_comment){

    std::stringstream out;
    out << label;
    string r = "", _ = (with_comment ? comment : "" ) + "L" + out.str() + ": ";
    
    opd *opds[] = {arg0, arg1, arg2};
    
    switch (op ){
        default:
            break;
    }
    
    for (int i = 0; i < 3; ++ i) {
        if (opds[i]) {
            r += (0 == i ? "" : ", ") + opds[i]->to_string();
        }
    }
    
    switch (op ){
        default:
            break;
    }
    
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x6200
leaq 0xc0(%rsp), %rdi
movl 0x8(%r15), %esi
callq 0x61e0
leaq 0xb360(%rip), %r14      # 0x25372
leaq 0x90(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6d6c
testb %bpl, %bpl
je 0x1a03a
leaq 0x28(%r15), %rsi
leaq 0x10(%rsp), %rdi
callq 0x63e0
jmp 0x1a050
leaq 0xb331(%rip), %rsi      # 0x25372
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6d6c
leaq 0xb66a(%rip), %rdx      # 0x256c1
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x12447
leaq 0xc8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x6480
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x12466
leaq 0x9624(%rip), %rdx      # 0x236b7
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x12447
leaq 0x50(%rsp), %rdi
callq 0x65c8
leaq 0x70(%rsp), %rdi
callq 0x65c8
leaq 0x30(%rsp), %rdi
callq 0x65c8
leaq 0x10(%rsp), %rdi
callq 0x65c8
testb %bpl, %bpl
movups 0x10(%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
xorl %r13d, %r13d
leaq 0x30(%rsp), %r15
leaq 0x9954(%rip), %rbp      # 0x23a46
leaq 0x50(%rsp), %r12
cmpq $0x3, %r13
je 0x1a144
movq 0x10(%rsp,%r13,8), %rsi
testq %rsi, %rsi
je 0x1a13f
movq %r15, %rdi
callq 0x18390
testq %r13, %r13
movq %rbp, %rsi
cmoveq %r14, %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x1256a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x65b0
movq %r12, %rdi
callq 0x65c8
movq %r15, %rdi
callq 0x65c8
incq %r13
jmp 0x1a0f7
leaq 0x90(%rsp), %rdi
callq 0x65c8
leaq 0xb0(%rsp), %rdi
callq 0x6240
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a175
movq %rax, %r14
jmp 0x1a1ee
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x65c8
jmp 0x1a18c
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x65c8
jmp 0x1a19b
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x65c8
jmp 0x1a1aa
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x65c8
testb %bpl, %bpl
jmp 0x1a1ee
jmp 0x1a1bb
movq %rax, %r14
jmp 0x1a1f6
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x65c8
jmp 0x1a1d7
movq %rax, %r14
jmp 0x1a1e1
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x65c8
leaq 0x90(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x65c8
leaq 0xb0(%rsp), %rdi
callq 0x6240
movq %r14, %rdi
callq 0x6530
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/optimizer.cpp
// Function: next_instruction_jumps(Block&)
void next_instruction_jumps(Block& code){
    if ( code.w_vector ){
        unsigned int nsize = code.instructions.vinst->size();
        
        // Guardar las instrucciones que no sean saltos a la siguiente
        // instruccion
        vector<inst*> new_insts;
        for (unsigned int i=0; i+1<nsize; i++){
            quad* current_inst = (quad*)(*(code.instructions.vinst))[i];
            quad* next_inst    = (quad*)(*(code.instructions.vinst))[i+1];
            
            if (    current_inst->op == quad::GOTO 
                 && current_inst->get_goal_label() == next_inst->label
               )
            {
                delete current_inst;
                (*(code.instructions.vinst))[i] = 0;
            } else {
                new_insts.push_back( current_inst );
            }
        }
        if ( nsize ){
            new_insts.push_back( code.instructions.vinst->back() );
        }
        unsigned int goal_size = new_insts.size();
        
        code.instructions.vinst->clear();
        for (unsigned int i=0; i<goal_size; i++){
            code.instructions.vinst->push_back( new_insts[i] );
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x4(%rdi)
jne 0x1a353
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rcx, 0x18(%rsp)
movl %ecx, %r15d
pushq $0x1
popq %rbp
leaq 0x20(%rsp), %r12
cmpq %r15, %rbp
jae 0x1a2ed
movq 0x8(%rbx), %rax
movq (%rax), %rax
movq -0x8(%rax,%rbp,8), %r13
cmpl $0x16, 0xc(%r13)
jne 0x1a2d8
movq (%rax,%rbp,8), %r14
movq %r13, %rdi
callq 0x187b8
cmpl 0x8(%r14), %eax
jne 0x1a2d8
movq %r13, %rdi
callq 0x1a20c
movq %r13, %rdi
pushq $0x48
popq %rsi
callq 0x62e0
movq 0x8(%rbx), %rax
movq (%rax), %rax
andq $0x0, -0x8(%rax,%rbp,8)
jmp 0x1a2e8
movq %r13, 0x20(%rsp)
movq %rsp, %rdi
movq %r12, %rsi
callq 0x1a5d6
incq %rbp
jmp 0x1a28c
movq 0x8(%rbx), %rax
cmpl $0x0, 0x18(%rsp)
je 0x1a30c
movq 0x8(%rax), %rsi
addq $-0x8, %rsi
movq %rsp, %rdi
callq 0x178d0
movq 0x8(%rbx), %rax
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
shrq $0x3, %rcx
movq (%rax), %rdx
cmpq %rdx, 0x8(%rax)
je 0x1a326
movq %rdx, 0x8(%rax)
movl %ecx, %r14d
shlq $0x3, %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x1a34b
movq 0x8(%rbx), %rdi
movq (%rsp), %rsi
addq %r15, %rsi
callq 0x178d0
addq $0x8, %r15
jmp 0x1a330
movq %rsp, %rdi
callq 0x1a5b8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a368
jmp 0x1a368
jmp 0x1a368
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a5b8
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/string_table.cpp
// Function: string_table::string_table()
string_table::string_table() {
    offset = 0;
    push_back("Se trató de utilizar una propiedad no activa de la unión en (");
    push_back(", ");
    push_back(")");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
andl $0x0, (%rdi)
leaq 0xacb7(%rip), %rsi      # 0x257e3
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6d6c
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x1abf2
leaq 0x48(%rsp), %rdi
callq 0x65c8
leaq 0x8eed(%rip), %rsi      # 0x23a46
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6d6c
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1abf2
leaq 0x28(%rsp), %rdi
callq 0x65c8
leaq 0x8972(%rip), %rsi      # 0x234f8
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6d6c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1abf2
leaq 0x8(%rsp), %rdi
callq 0x65c8
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x1abd4
jmp 0x1abdb
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x1abd4
jmp 0x1abdb
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x65c8
jmp 0x1abde
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x1646a
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/string_table.cpp
// Function: string_table::push_back(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int string_table::push_back(string s) {
    table.push_back(s);
    int t = offset;
    offset += s.length() + 1;//El null para asciiz
    return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x1ad6a
movl (%r14), %eax
movl 0x8(%rbx), %ecx
addl %eax, %ecx
incl %ecx
movl %ecx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/string_table.cpp
// Function: string_table::to_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string string_table::to_string(string s) {
    string ss = "";
    for (unsigned int i = 0; i < s.length(); ++ i) {
        if ('\\' == s[i]) ss += '\\';
        ss += s[i];
    }
    return ss;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa740(%rip), %rsi      # 0x25372
leaq 0x7(%rsp), %rdx
callq 0x6d6c
xorl %r15d, %r15d
pushq $0x5c
popq %rbp
movl %r15d, %r15d
cmpq %r15, 0x8(%r14)
jbe 0x1ac77
movq (%r14), %rax
movb (%rax,%r15), %al
cmpb $0x5c, %al
jne 0x1ac67
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6280
movq (%r14), %rax
movb (%rax,%r15), %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6280
incl %r15d
jmp 0x1ac42
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x65c8
movq %r14, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/main.cpp
// Function: main_ast_create(main_args)
AST* main_ast_create(main_args args){

    p = new AST();
    yyin = args.in;
    do {
        yyparse();
    } while (!feof(yyin));

    if (args.to_single_archive){
        main_redirect_stdout("bla.output");
    }
    return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x62d0
movq %rax, %r15
movq %rax, %rdi
callq 0x11bd8
movq %r15, 0x17a0d(%rip)     # 0x383c8
movq %r14, 0x17ace(%rip)     # 0x38490
callq 0x1aea0
movq 0x17ac2(%rip), %rdi     # 0x38490
callq 0x6460
testl %eax, %eax
je 0x209c2
testb $0x1, %bl
je 0x209e8
leaq 0x819f(%rip), %rdi      # 0x28b82
callq 0x20a85
movq 0x179d9(%rip), %rax     # 0x383c8
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/main.cpp
// Function: main_ast_check(AST*)
string_table* main_ast_check(AST *ast){

    string_table* strings = new string_table();
    symbol_table* st = new symbol_table(strings);
    
    ast->fill_and_check(st);
    
    delete st;

    return strings;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x62d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ab0c
pushq $0x48
popq %rdi
callq 0x62d0
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x141d0
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x8(%rax)
movq %r15, %rdi
callq 0x122be
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0x62e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x48
popq %rsi
movq %r15, %rdi
jmp 0x20a78
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x62e0
movq %r14, %rdi
callq 0x6530