LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_break::AST_break(token*)
AST_break::AST_break(token* t){
    line = t->line;
    column = t->column;
    delete t;
    
    has_return = NO;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x21200
movq 0x8(%rsp), %rax
leaq 0x4e037(%rip), %rcx     # 0x6d740
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1f744
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x63a0
movq 0x8(%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_continue::AST_continue(token*)
AST_continue::AST_continue(token* t){
    line = t->line;
    column = t->column;
    delete t;
    
    has_return = NO;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x21200
movq 0x8(%rsp), %rax
leaq 0x4dfdf(%rip), %rcx     # 0x6d768
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1f7c4
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x63a0
movq 0x8(%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_read::AST_read(tokenId*)
AST_read::AST_read(tokenId* t){
    line = t->line;
    column = t->line;
    
    variable = string(t->ident);
    delete t;
    
    has_return = NO;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21200
movq 0x10(%rsp), %rdi
leaq 0x4df97(%rip), %rax     # 0x6d7a0
movq %rax, (%rdi)
addq $0x78, %rdi
movq %rdi, 0x8(%rsp)
callq 0x6560
movq 0x10(%rsp), %rax
movq 0x48(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x48(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdi
callq 0x6170
jmp 0x1f848
movq 0x10(%rsp), %rdi
addq $0x78, %rdi
leaq 0x28(%rsp), %rsi
callq 0x64c0
leaq 0x28(%rsp), %rdi
callq 0x6778
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1f88b
movq (%rsp), %rdi
callq 0x20f10
movq (%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
movq 0x10(%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x58, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x6778
movq 0x10(%rsp), %rdi
callq 0x21540
movq 0x20(%rsp), %rdi
callq 0x66b0
nopl (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST.cpp
// Function: AST_print::add_argument(AST_expression*)
void AST_print::add_argument(AST_expression* e){
    list.push_back(e);
    
    if ( list.size() == 1 ){
        line   = e->line;
        column = e->column;
    }
    has_return = NO;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x78, %rdi
leaq 0x8(%rsp), %rsi
callq 0x21110
movq (%rsp), %rdi
addq $0x78, %rdi
callq 0x1ffd0
cmpq $0x1, %rax
jne 0x1f972
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq (%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x21200
movq 0x18(%rsp), %rdi
leaq 0x4de32(%rip), %rax     # 0x6d7f0
movq %rax, (%rdi)
subq $-0x80, %rdi
movq %rdi, 0x10(%rsp)
callq 0x6560
movq 0x18(%rsp), %rax
movq 0x58(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x58(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x58(%rsp), %rcx
movq %rcx, 0x78(%rax)
movq 0x50(%rsp), %rsi
addq $0x8, %rsi
leaq 0x30(%rsp), %rdi
callq 0x6170
jmp 0x1fa08
movq 0x18(%rsp), %rdi
addq $0x80, %rdi
leaq 0x30(%rsp), %rsi
callq 0x64c0
leaq 0x30(%rsp), %rdi
callq 0x6778
movq 0x18(%rsp), %rax
movq $0x0, 0xa0(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1fa61
movq 0x8(%rsp), %rdi
callq 0x20f10
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
movq 0x18(%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x6778
movq 0x18(%rsp), %rdi
callq 0x21540
movq 0x28(%rsp), %rdi
callq 0x66b0
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21200
movq 0x10(%rsp), %rdi
leaq 0x4dd45(%rip), %rax     # 0x6d818
movq %rax, (%rdi)
addq $0x88, %rdi
movq %rdi, 0x8(%rsp)
callq 0x6560
movq 0x10(%rsp), %rax
movq 0x58(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x58(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x58(%rsp), %rcx
movq %rcx, 0x78(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x80(%rax)
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdi
callq 0x6170
jmp 0x1fb2c
movq 0x10(%rsp), %rdi
addq $0x88, %rdi
leaq 0x28(%rsp), %rsi
callq 0x64c0
leaq 0x28(%rsp), %rdi
callq 0x6778
movq 0x10(%rsp), %rax
movq $0x0, 0xa8(%rax)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1fb82
movq (%rsp), %rdi
callq 0x20f10
movq (%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
movq 0x10(%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x68, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x6778
movq 0x10(%rsp), %rdi
callq 0x21540
movq 0x20(%rsp), %rdi
callq 0x66b0
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x21630
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
callq 0x21650
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
callq 0x216a0
movq %rax, 0x58(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x21680
testb $0x1, %al
jne 0x20435
jmp 0x20521
leaq 0x68(%rsp), %rdi
callq 0x216d0
movq 0x20(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
testb $0x1, 0x32(%rax)
je 0x20510
movq 0x50(%rsp), %rax
testb $0x1, 0x31(%rax)
jne 0x20510
leaq 0x4e06b(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x48, %rdi
leaq 0x33ce4(%rip), %rsi     # 0x5415f
callq 0x6370
movq %rax, 0x20(%rsp)
jmp 0x20487
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x295b0
jmp 0x20498
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6340
movq %rax, 0x18(%rsp)
jmp 0x204ae
movq 0x18(%rsp), %rdi
leaq 0x371fd(%rip), %rsi     # 0x576b7
callq 0x6370
jmp 0x204c1
leaq 0x30(%rsp), %rdi
callq 0x6778
leaq 0x4e006(%rip), %rax     # 0x6e4d8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x29600
movl %eax, 0x14(%rsp)
jmp 0x204ea
movq 0x50(%rsp), %rdi
callq 0x29610
movl %eax, 0x4(%rsp)
jmp 0x204fa
movl 0x4(%rsp), %edx
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdi
callq 0x2f160
jmp 0x2050e
jmp 0x20510
jmp 0x20512
leaq 0x68(%rsp), %rdi
callq 0x21700
jmp 0x2040a
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
callq 0x21730
addq $0x78, %rsp
retq
movq %rax, %rdi
callq 0x7820
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x29354
cmpl $0x0, 0xc(%rsp)
jne 0x29354
movl $0x1, 0x14(%rsp)
jmp 0x29390
cvtsi2sdl 0x10(%rsp), %xmm0
cvtsi2sdl 0xc(%rsp), %xmm1
mulsd %xmm1, %xmm0
callq 0x29470
movsd %xmm0, (%rsp)
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
callq 0x292f0
movsd (%rsp), %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0xc, %edi
callq 0x6030
movq %rax, 0x8(%rsp)
movl $0xc, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rsp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, 0x14(%rsp)
jle 0x29414
movl 0x14(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x14(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, 0x14(%rsp)
jmp 0x293d6
xorl %eax, %eax
cmpl 0x4(%rsp), %eax
jge 0x2945a
movl $0x0, (%rsp)
movl (%rsp), %eax
addl 0x4(%rsp), %eax
cmpl $0xc, %eax
jge 0x29458
movq 0x8(%rsp), %rax
movl (%rsp), %ecx
addl 0x4(%rsp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x29423
jmp 0x2945a
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x58, %rsp
movq %rsi, 0x18(%rsp)
movb 0x60(%rsp), %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
andb $0x1, %dl
movb %dl, 0x47(%rsp)
movl %ecx, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
movl %r9d, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x6560
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x8(%rsp)
callq 0x298e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6060
jmp 0x2952c
movq (%rsp), %rax
movb 0x47(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movl 0x40(%rsp), %ecx
movl %ecx, 0x24(%rax)
movl 0x3c(%rsp), %ecx
movl %ecx, 0x28(%rax)
movl 0x38(%rsp), %ecx
movl %ecx, 0x2c(%rax)
movb 0x37(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
movb $0x0, 0x31(%rax)
movl $0x0, 0x38(%rax)
movl $0x1, 0x3c(%rax)
movl $0x0, 0x34(%rax)
movl $0xffffffff, 0x40(%rax) # imm = 0xFFFFFFFF
movb $0x1, 0x32(%rax)
addq $0x58, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x298f0
movq 0x10(%rsp), %rdi
callq 0x6778
movq 0x28(%rsp), %rdi
callq 0x66b0
nop
// File: 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:
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x29490
movq 0x10(%rsp), %rdi
addq $0x78, %rdi
movq %rdi, 0x8(%rsp)
callq 0x21420
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6060
jmp 0x296b3
movq 0x10(%rsp), %rax
movl $0x2, 0x24(%rax)
movb $0x1, 0x20(%rax)
movl 0x54(%rsp), %ecx
movl %ecx, 0x28(%rax)
movl 0x50(%rsp), %ecx
movl %ecx, 0x2c(%rax)
movb $0x0, 0x30(%rax)
movb $0x1, 0x31(%rax)
movb $0x1, 0x32(%rax)
movl $0xffffffff, 0x3c(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x40(%rax) # imm = 0xFFFFFFFF
leaq 0x30(%rsp), %rdi
callq 0x29900
movq 0x48(%rsp), %rdi
callq 0x28a00
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
callq 0x28840
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x29920
testb $0x1, %al
jne 0x29732
jmp 0x29789
movq 0x10(%rsp), %rax
addq $0x78, %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0x28d90
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x29960
jmp 0x29757
jmp 0x29759
leaq 0x30(%rsp), %rdi
callq 0x299d0
jmp 0x2970e
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x21460
movq 0x10(%rsp), %rdi
callq 0x299f0
jmp 0x2978e
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x66b0
nopl (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/symbol_table.cpp
// Function: symbol_table::symbol_table(symbol_table*, string_table*)
symbol_table::symbol_table(symbol_table* p, string_table* s){
    parent = p;
    strings = s;
    
    if ( p == 0 || p->parent == 0 ){
        accumulated_offset = 0;
    } else if ( p != 0 && p->parent != 0 ){
        accumulated_offset = p->accumulated_offset;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0x2a3a0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x18(%rsp)
je 0x29fff
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2a00d
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
jmp 0x2a032
cmpq $0x0, 0x18(%rsp)
je 0x2a030
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2a030
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
jmp 0x2a032
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x21630
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x2a3b0
movq 0x20(%rsp), %rdi
movq %rax, 0x68(%rsp)
addq $0x18, %rdi
callq 0x216a0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x21680
testb $0x1, %al
jne 0x2a0b8
jmp 0x2a0ee
cmpq $0x0, 0x78(%rsp)
je 0x2a0cb
movq 0x78(%rsp), %rax
movl $0x0, (%rax)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x2a3e0
movq (%rax), %rax
movq %rax, 0x90(%rsp)
jmp 0x2a19c
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x2a190
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6170
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x2a040
movq %rax, 0x10(%rsp)
jmp 0x2a138
leaq 0x38(%rsp), %rdi
callq 0x6778
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x2a181
movq 0x78(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq 0x78(%rsp), %rax
movl %ecx, (%rax)
jmp 0x2a181
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6778
jmp 0x2a1ac
movq 0x58(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x2a19c
movq $0x0, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x18, %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x295b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2a520
movq %rax, 0x20(%rsp)
jmp 0x2a23f
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x6778
movq (%rsp), %rdi
movq 0x58(%rsp), %rax
movl 0x3c(%rax), %edx
xorl %esi, %esi
callq 0x2a2d0
movq (%rsp), %rdi
movl 0xc(%rdi), %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x34(%rax)
movl 0x8(%rdi), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rdi)
movq 0x58(%rsp), %rax
movl %ecx, 0x40(%rax)
movq 0x58(%rsp), %rax
movl 0x38(%rax), %esi
movq 0x58(%rsp), %rax
movl 0x3c(%rax), %edx
callq 0x2a2d0
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6778
movq 0x30(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpl $0x0, -0x10(%rsp)
jg 0x2a2f0
jmp 0x2a327
movq -0x18(%rsp), %rax
movl -0x10(%rsp), %ecx
movl %ecx, -0x1c(%rsp)
movl 0xc(%rax), %eax
xorl %edx, %edx
divl -0x10(%rsp)
movl -0x1c(%rsp), %eax
subl %edx, %eax
xorl %edx, %edx
divl -0x10(%rsp)
movq -0x18(%rsp), %rax
addl 0xc(%rax), %edx
movl %edx, 0xc(%rax)
movl -0xc(%rsp), %ecx
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2cef0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x41a3a(%rip), %rax     # 0x6dbf0
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x6060
jmp 0x2c1c4
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0x28(%rax)
movl $0x4, 0x2c(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x30(%rax)
addq $0x38, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x21600
movq 0x18(%rsp), %rdi
callq 0x66b0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x2cf40
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
leaq 0x419b7(%rip), %rax     # 0x6dc08
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x6060
jmp 0x2c25f
movq 0x38(%rsp), %rax
movl $0x0, 0x28(%rax)
movl $0x1, 0x2c(%rax)
movq 0x70(%rsp), %rcx
movq %rcx, 0x30(%rax)
leaq 0x58(%rsp), %rdi
callq 0x21630
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rdi
addq $0x18, %rdi
callq 0x21650
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rdi
addq $0x18, %rdi
callq 0x216a0
movq %rax, 0x48(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x21680
testb $0x1, %al
jne 0x2c2d5
jmp 0x2c3d0
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2b1a0
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq 0x20(%rcx), %rcx
movl $0x0, 0x34(%rcx)
addq $0x28, %rax
movq %rax, 0x28(%rsp)
callq 0x2b1a0
movq 0x20(%rax), %rdi
callq 0x295f0
movl %eax, 0x34(%rsp)
jmp 0x2c319
movl 0x34(%rsp), %eax
movslq %eax, %rsi
leaq 0x421b9(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x28(%rsp), %rdi
movq (%rax), %rsi
addq $0x28, %rsi
callq 0x2cf70
movq %rax, 0x18(%rsp)
jmp 0x2c344
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x28(%rax)
movl 0x2c(%rax), %eax
movl %eax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2b1a0
movq 0x20(%rax), %rdi
callq 0x295f0
movl %eax, 0x14(%rsp)
jmp 0x2c373
movl 0x14(%rsp), %eax
movslq %eax, %rsi
leaq 0x4215f(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movl 0x10(%rsp), %edi
movq (%rax), %rax
movl 0x2c(%rax), %esi
callq 0x29330
movl %eax, 0xc(%rsp)
jmp 0x2c39b
movq 0x38(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x2c(%rax)
leaq 0x58(%rsp), %rdi
callq 0x21700
jmp 0x2c2a6
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x2cfb0
jmp 0x2c3e6
movq 0x38(%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x28(%rax)
addq $0x88, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x66b0
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2cef0
movq 0x8(%rsp), %rdi
leaq 0x41802(%rip), %rax     # 0x6dc20
movq %rax, (%rdi)
movl $0x4, 0x28(%rdi)
movl $0x4, 0x2c(%rdi)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x30(%rdi)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x34(%rdi)
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x6060
jmp 0x2c458
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2c48c
movq (%rsp), %rdi
callq 0x20f10
movq (%rsp), %rdi
movl $0x28, %esi
callq 0x63a0
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x21600
movq 0x18(%rsp), %rdi
callq 0x66b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movl %edx, 0x1e4(%rsp)
movl %ecx, 0x1e0(%rsp)
movl %r8d, 0x1dc(%rsp)
movq 0x1f0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x2cef0
movq 0x38(%rsp), %rax
leaq 0x41785(%rip), %rcx     # 0x6dc90
movq %rcx, (%rax)
leaq 0x50(%rsp), %rdi
callq 0x6290
jmp 0x2c51a
leaq 0x60(%rsp), %rdi
leaq 0x27cea(%rip), %rsi     # 0x54210
callq 0x6370
movq %rax, 0x30(%rsp)
jmp 0x2c532
movq 0x30(%rsp), %rdi
leaq 0x25f9e(%rip), %rsi     # 0x524dc
callq 0x6370
movq %rax, 0x28(%rsp)
jmp 0x2c54a
movq 0x28(%rsp), %rdi
movl 0x1dc(%rsp), %esi
callq 0x6690
movq %rax, 0x20(%rsp)
jmp 0x2c562
movq 0x20(%rsp), %rdi
leaq 0x26110(%rip), %rsi     # 0x5267e
callq 0x6370
movq %rax, 0x18(%rsp)
jmp 0x2c57a
movq 0x18(%rsp), %rdi
movl 0x1e0(%rsp), %esi
callq 0x6690
movq %rax, 0x10(%rsp)
jmp 0x2c592
movq 0x10(%rsp), %rdi
leaq 0x27c78(%rip), %rsi     # 0x54216
callq 0x6370
movq %rax, 0x8(%rsp)
jmp 0x2c5aa
movq 0x8(%rsp), %rdi
movq 0x1e8(%rsp), %rsi
addq $0x8, %rsi
callq 0x6340
jmp 0x2c5c2
movq 0x38(%rsp), %rsi
addq $0x8, %rsi
leaq 0x50(%rsp), %rdi
callq 0x64f0
jmp 0x2c5d7
movq 0x1e8(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x40(%rsp)
movq 0x1e8(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x40(%rsp), %eax
movq 0x1e8(%rsp), %rcx
xorl %edx, %edx
divl 0x2c(%rcx)
movl 0x4(%rsp), %eax
subl %edx, %eax
movq 0x1e8(%rsp), %rcx
xorl %edx, %edx
divl 0x2c(%rcx)
movq 0x38(%rsp), %rax
addl 0x40(%rsp), %edx
movl %edx, 0x40(%rsp)
movl 0x40(%rsp), %ecx
movl 0x1e0(%rsp), %edx
subl 0x1dc(%rsp), %edx
imull %edx, %ecx
movl %ecx, 0x28(%rax)
movq 0x1e8(%rsp), %rcx
movl 0x2c(%rcx), %ecx
movl %ecx, 0x2c(%rax)
movl 0x1dc(%rsp), %ecx
movl %ecx, 0x30(%rax)
movl 0x1e0(%rsp), %ecx
movl %ecx, 0x34(%rax)
movl 0x1e0(%rsp), %ecx
subl 0x1dc(%rsp), %ecx
movl %ecx, 0x38(%rax)
movl 0x1e4(%rsp), %ecx
movl %ecx, 0x3c(%rax)
leaq 0x50(%rsp), %rdi
callq 0x62d0
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x2c6b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x62d0
movq 0x38(%rsp), %rdi
callq 0x21600
movq 0x48(%rsp), %rdi
callq 0x66b0
nopl (%rax)
// File: 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:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdx, 0x8(%rsp)
movq %rdi, 0x1c0(%rsp)
movl %esi, 0x1bc(%rsp)
movq %rdx, 0x1b0(%rsp)
movq 0x1c0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2cef0
movq 0x10(%rsp), %rax
leaq 0x41597(%rip), %rcx     # 0x6dca8
movq %rcx, (%rax)
movl 0x1bc(%rsp), %ecx
movl %ecx, 0x30(%rax)
leaq 0x28(%rsp), %rdi
callq 0x6290
jmp 0x2c72a
leaq 0x38(%rsp), %rdi
leaq 0x27ae6(%rip), %rsi     # 0x5421c
callq 0x6370
movq %rax, (%rsp)
jmp 0x2c741
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x6340
jmp 0x2c751
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdi
callq 0x64f0
jmp 0x2c766
movq 0x10(%rsp), %rax
movl $0x4, 0x28(%rax)
movl $0x4, 0x2c(%rax)
leaq 0x28(%rsp), %rdi
callq 0x62d0
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x2c7b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x62d0
movq 0x10(%rsp), %rdi
callq 0x21600
movq 0x20(%rsp), %rdi
callq 0x66b0
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x27763(%rip), %rsi     # 0x54267
callq 0x6370
movq 0x18(%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x27709(%rip), %rsi     # 0x5422d
callq 0x6370
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x276f2(%rip), %rsi     # 0x54235
callq 0x6370
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0x2c(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x254db(%rip), %rsi     # 0x5203d
callq 0x6370
movq %rax, %rdi
movq 0x41427(%rip), %rsi     # 0x6df98
callq 0x63d0
movq %rax, %rdi
leaq 0x276ce(%rip), %rsi     # 0x5424e
callq 0x6370
movq %rax, %rdi
movq 0x41409(%rip), %rsi     # 0x6df98
callq 0x63d0
leaq 0x40(%rsp), %rdi
callq 0x21630
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
addq $0x18, %rdi
callq 0x21650
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
addq $0x18, %rdi
callq 0x216a0
movq %rax, 0x30(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x21680
testb $0x1, %al
jne 0x2cbee
jmp 0x2cc7e
movq 0x48(%rsp), %rdi
leaq 0x2765c(%rip), %rsi     # 0x54256
callq 0x6370
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2b1a0
movq 0x20(%rax), %rdi
callq 0x295f0
movslq %eax, %rsi
leaq 0x418bf(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
movl $0x20, %esi
callq 0x6480
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2b1a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x6340
movq %rax, %rdi
movq 0x4132e(%rip), %rsi     # 0x6df98
callq 0x63d0
leaq 0x40(%rsp), %rdi
callq 0x21700
jmp 0x2cbbf
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
addq $0x18, %rdi
callq 0x21650
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x30(%rax), %rdi
addq $0x18, %rdi
callq 0x216a0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2b0a0
testb $0x1, %al
jne 0x2ccc4
jmp 0x2cce4
movq 0x48(%rsp), %rdi
leaq 0x27591(%rip), %rsi     # 0x54261
callq 0x6370
movq %rax, %rdi
movq 0x412b9(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x48(%rsp), %rdi
leaq 0x2755e(%rip), %rsi     # 0x5424e
callq 0x6370
movq %rax, %rdi
movq 0x41299(%rip), %rsi     # 0x6df98
callq 0x63d0
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x2753e(%rip), %rsi     # 0x54272
callq 0x6370
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x274d9(%rip), %rsi     # 0x5422d
callq 0x6370
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x274c2(%rip), %rsi     # 0x54235
callq 0x6370
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x2c(%rax), %esi
callq 0x6690
movq %rax, %rdi
leaq 0x252ab(%rip), %rsi     # 0x5203d
callq 0x6370
movq %rax, %rdi
movq 0x411f7(%rip), %rsi     # 0x6df98
callq 0x63d0
movq %rax, %rdi
leaq 0x2749e(%rip), %rsi     # 0x5424e
callq 0x6370
movq %rax, %rdi
movq 0x411d9(%rip), %rsi     # 0x6df98
callq 0x63d0
leaq 0x30(%rsp), %rdi
callq 0x20220
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x20240
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x20290
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x20270
testb $0x1, %al
jne 0x2ce13
jmp 0x2ce61
movq 0x38(%rsp), %rdi
leaq 0x27437(%rip), %rsi     # 0x54256
callq 0x6370
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0x202c0
movq %rax, %rdi
callq 0x6160
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x6370
movq %rax, %rdi
movq 0x41148(%rip), %rsi     # 0x6df98
callq 0x63d0
leaq 0x30(%rsp), %rdi
callq 0x202f0
jmp 0x2cdeb
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x20240
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x38(%rax), %rdi
callq 0x20290
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2cfc0
testb $0x1, %al
jne 0x2ce9f
jmp 0x2cebf
movq 0x38(%rsp), %rdi
leaq 0x273b6(%rip), %rsi     # 0x54261
callq 0x6370
movq %rax, %rdi
movq 0x410de(%rip), %rsi     # 0x6df98
callq 0x63d0
movq 0x38(%rsp), %rdi
leaq 0x27383(%rip), %rsi     # 0x5424e
callq 0x6370
movq %rax, %rdi
movq 0x410be(%rip), %rsi     # 0x6df98
callq 0x63d0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
movq 0x20(%rsp), %rsi
addq $0x8, %rsi
callq 0x2de60
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x18, %rdi
callq 0x244c0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x244a0
testb $0x1, %al
jne 0x2d8a7
jmp 0x2d8f5
movq 0x8(%rsp), %rdi
callq 0x2df80
movq 0x8(%rsp), %rdi
movl %eax, 0x4(%rsp)
addq $0x18, %rdi
movq 0x20(%rsp), %rsi
addq $0x8, %rsi
callq 0x2de90
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, (%rax)
leaq 0x20(%rsp), %rsi
callq 0x2dfa0
movq 0x8(%rsp), %rdi
callq 0x2df80
subq $0x1, %rax
movl %eax, 0x34(%rsp)
jmp 0x2d906
leaq 0x18(%rsp), %rdi
callq 0x24540
movl 0x20(%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x26590(%rip), %rsi     # 0x542d4
callq 0x6370
movq %rax, %rdi
movq 0x40245(%rip), %rsi     # 0x6df98
callq 0x63d0
leaq 0x20(%rsp), %rdi
callq 0x2e040
movq 0x8(%rsp), %rdi
callq 0x20140
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
callq 0x201b0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x20170
testb $0x1, %al
jne 0x2dd9f
jmp 0x2ddc2
leaq 0x20(%rsp), %rdi
callq 0x201e0
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
leaq 0x20(%rsp), %rdi
callq 0x20320
jmp 0x2dd7b
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movl %esi, 0x10c(%rsp)
movl %edx, 0x108(%rsp)
movq 0x110(%rsp), %rsi
movq %rsi, 0x50(%rsp)
addq $0x38, %rsi
movq %rsi, 0x58(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x6360
leaq 0xc7(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x66c0
movq 0x60(%rsp), %rdx
leaq 0x25194(%rip), %rsi     # 0x54352
leaq 0xc8(%rsp), %rdi
callq 0x7500
jmp 0x2f1cd
movq 0x58(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x6440
jmp 0x2f1e1
leaq 0xc8(%rsp), %rdi
callq 0x6778
leaq 0xc7(%rsp), %rdi
callq 0x6400
movq 0x50(%rsp), %rdi
addq $0x48, %rdi
leaq 0x250d1(%rip), %rsi     # 0x542dc
callq 0x6370
movq %rax, 0x48(%rsp)
jmp 0x2f217
movq 0x48(%rsp), %rdi
movl 0x10c(%rsp), %esi
callq 0x6690
movq %rax, 0x40(%rsp)
jmp 0x2f22f
movq 0x40(%rsp), %rdi
leaq 0x2509f(%rip), %rsi     # 0x542da
callq 0x6370
movq %rax, 0x38(%rsp)
jmp 0x2f247
movq 0x38(%rsp), %rdi
movl 0x108(%rsp), %esi
callq 0x6690
movq %rax, 0x30(%rsp)
jmp 0x2f25f
movq 0x30(%rsp), %rdi
leaq 0x23438(%rip), %rsi     # 0x526a3
callq 0x6370
movq %rax, 0x28(%rsp)
jmp 0x2f277
movq 0x28(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x6340
jmp 0x2f28b
movq 0x50(%rsp), %rdi
leaq 0x10c(%rsp), %rsi
callq 0x2f910
movq %rax, 0x20(%rsp)
jmp 0x2f2a4
movq 0x20(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x2fa00
movq %rax, 0x18(%rsp)
jmp 0x2f2bd
movq 0x50(%rsp), %rsi
addq $0x38, %rsi
leaq 0x90(%rsp), %rdi
callq 0x6360
jmp 0x2f2d5
movq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x2faf0
jmp 0x2f2e9
leaq 0x90(%rsp), %rdi
callq 0x6778
movq 0x50(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x8(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x66c0
movq 0x10(%rsp), %rdx
leaq 0x25033(%rip), %rsi     # 0x54352
leaq 0x70(%rsp), %rdi
callq 0x7500
jmp 0x2f32b
movq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x6440
jmp 0x2f33c
leaq 0x70(%rsp), %rdi
callq 0x6778
leaq 0x6f(%rsp), %rdi
callq 0x6400
leaq 0xe8(%rsp), %rdi
callq 0x6778
addq $0x118, %rsp            # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x2f39c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x6778
leaq 0xc7(%rsp), %rdi
callq 0x6400
jmp 0x2f422
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x2f422
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x6778
jmp 0x2f422
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x2f418
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x6778
leaq 0x6f(%rsp), %rdi
callq 0x6400
leaq 0xe8(%rsp), %rdi
callq 0x6778
movq 0xb8(%rsp), %rdi
callq 0x66b0
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2fb20
movq 0x8(%rsp), %rdi
callq 0x2fb40
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2fb90
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2fb70
testb $0x1, %al
jne 0x2f7c2
jmp 0x2f8df
leaq 0x38(%rsp), %rdi
callq 0x2fbc0
leaq 0x50(%rsp), %rdi
callq 0x2fbe0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x2fc00
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2fbe0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x2fc50
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2fc30
testb $0x1, %al
jne 0x2f824
jmp 0x2f8ce
leaq 0x20(%rsp), %rdi
callq 0x2fc80
leaq 0x38(%rsp), %rdi
callq 0x2fca0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x2fcc0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2fca0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x2fd30
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2fcf0
testb $0x1, %al
jne 0x2f883
jmp 0x2f8bd
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2fd60
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x6340
movq %rax, %rdi
movq 0x3e6ec(%rip), %rsi     # 0x6df98
callq 0x63d0
leaq 0x20(%rsp), %rdi
callq 0x2fd70
jmp 0x2f853
jmp 0x2f8bf
leaq 0x38(%rsp), %rdi
callq 0x2fd90
jmp 0x2f7f1
jmp 0x2f8d0
leaq 0x50(%rsp), %rdi
callq 0x2fdc0
jmp 0x2f79b
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x18, %rdi
movq %rdi, 0x18(%rsp)
callq 0x349e0
movq 0x20(%rsp), %rax
movb 0x3f(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x4(%rax)
testb $0x1, 0x3f(%rsp)
je 0x32d96
movl $0x18, %edi
callq 0x6390
movq %rax, 0x10(%rsp)
jmp 0x32d51
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x61e0
movq 0x10(%rsp), %rdi
callq 0x349f0
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x32dd0
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x34a10
jmp 0x32dd5
movl $0x18, %edi
callq 0x6390
movq %rax, 0x8(%rsp)
jmp 0x32da7
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x61e0
movq 0x8(%rsp), %rdi
callq 0x34a00
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x66b0
nop
// File: 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:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x32eb0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rsp)
testb $0x1, 0x4(%rax)
je 0x32e52
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x18(%rsp), %rsi
callq 0x34a70
testb $0x1, 0x17(%rsp)
je 0x32e50
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movq 0x8(%rax), %rdi
callq 0x34ae0
movl 0x4(%rsp), %ecx
movq (%rax), %rax
movl %ecx, 0x8(%rax)
jmp 0x32e8c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x18(%rsp), %rsi
callq 0x34b20
testb $0x1, 0x17(%rsp)
je 0x32e8a
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, (%rsp)
movq 0x8(%rax), %rdi
callq 0x34b60
movl (%rsp), %ecx
movq (%rax), %rax
movl %ecx, 0x8(%rax)
jmp 0x32e8c
testb $0x1, 0x17(%rsp)
je 0x32ea2
movl 0x3b5bb(%rip), %eax     # 0x6e454
addl $0x1, %eax
movl %eax, 0x3b5b2(%rip)     # 0x6e454
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/block.cpp
// Function: Block::last_instruction()
inst* Block::last_instruction(){
    if ( w_vector ){
        return instructions.vinst->back();
    } else {
        return instructions.linst->back();
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x4(%rax)
je 0x32eef
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x34ae0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x32f04
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x34b60
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop