LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Davidc2525[P]Leaf/compiler/registers/register.cpp
// Function: Register::Register(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool)
Register::Register(int id, string *name, int bits, string *word, bool reservable)
{
    this->id = id;
    this->name = name;
    this->bits = bits;
    this->word = word;
    this->reservable = reservable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movb $0x1, 0x20(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movb -0x29(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/registers/register.cpp
// Function: Register::dump()
const char *Register::dump()
{
    string *d_info = new string("Register@{");
    d_info->append("name: ");
    d_info->append(name->c_str());
    d_info->append(",bits: ");
    d_info->append(to_string(bits));
    d_info->append("}");
    return d_info->c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movb $0x1, -0x25(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6500
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x14a4c(%rip), %rsi     # 0x35e05
callq 0xada0
jmp 0x213c0
movb $0x0, -0x25(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x6340
movq -0x60(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x14a30(%rip), %rsi     # 0x35e10
callq 0x6540
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x6120
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x6540
movq -0x10(%rbp), %rdi
leaq 0x14a06(%rip), %rsi     # 0x35e17
callq 0x6540
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movl 0x10(%rax), %esi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xae50
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x6550
jmp 0x21441
leaq -0x48(%rbp), %rdi
callq 0x6588
movq -0x10(%rbp), %rdi
leaq 0x149ca(%rip), %rsi     # 0x35e1f
callq 0x6540
movq -0x10(%rbp), %rdi
callq 0x6120
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x6340
testb $0x1, -0x25(%rbp)
jne 0x21489
jmp 0x21497
movq -0x60(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0x214ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6588
movq -0x20(%rbp), %rdi
callq 0x64f0
nopw (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/registers/register_manager.cpp
// Function: RegisterManager::addProvider(RegisterProvider*)
int RegisterManager::addProvider(RegisterProvider *provider)
{
    int current = this->ids;
    this->ids++;

    providers[current] = provider;

    return current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl %ecx, -0x14(%rbp)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdx
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/registers/register_manager.cpp
// Function: RegisterManager::getProviderBy(int)
RegisterProvider *RegisterManager::getProviderBy(int arc)
{
    RegisterProvider *provider = NULL;

    for (int p = 0; p < ids; p++)
    {
        if(arc==providers[p]->getArc()){
            provider = providers[p];
            return provider;
        }
    }
    if(provider == NULL){
        throw "Proveedor no existe";
    }

    return provider;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl (%rcx), %eax
jge 0x216a4
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jne 0x21697
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x216da
jmp 0x21699
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x21646
cmpq $0x0, -0x20(%rbp)
jne 0x216d2
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x14762(%rip), %rax     # 0x35e21
movq %rax, (%rdi)
movq 0x288ef(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::lessBussy()
Register *RegisterProvider::lessBussy()
{
    Register *less = NULL;
    int gtr = 1000000;
    for (auto x = registers_.begin(); x != registers_.end(); x++)
    {
        if ((*reservers)[(*x)->id]->size() < gtr && (*x)->bits == getArc())
        {
            gtr = (*reservers)[(*x)->id]->size();
            less = get((*x)->id);
        }
    }
    if (less == NULL)
    {
        throw "No se pudo encotrar el registro menos usado.";
    }
    return less;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, -0x10(%rbp)
movl $0xf4240, -0x14(%rbp)   # imm = 0xF4240
addq $0x8, %rdi
callq 0x22330
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x223a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x22360
testb $0x1, %al
jne 0x21747
jmp 0x217ff
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x224b0
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
callq 0x223d0
movq (%rax), %rdi
callq 0x224d0
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jae 0x217e9
leaq -0x20(%rbp), %rdi
callq 0x224b0
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x44(%rbp)
movq (%rdi), %rax
callq *0x88(%rax)
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jne 0x217e9
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x224b0
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
callq 0x223d0
movq (%rax), %rdi
callq 0x224d0
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x224b0
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %esi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, -0x10(%rbp)
jmp 0x217eb
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x224f0
movq %rax, -0x30(%rbp)
jmp 0x21720
cmpq $0x0, -0x10(%rbp)
jne 0x2182d
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x1461b(%rip), %rax     # 0x35e35
movq %rax, (%rdi)
movq 0x28794(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::get(int)
Register *RegisterProvider::get(int id)
{
    Register *found = NULL;
    vector<Register *>::iterator it = registers_.begin();
    for (std::vector<Register *>::iterator x = it; x != registers_.end(); x++)
    {
        if (((Register *)*x)->id == id)
        {
            int dis = distance(it, x);
            found = registers_[dis];
            //cout << ";index: " << dis << " reg: " << registers_[dis]->getName() << endl;
        }
    }
    return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x8, %rdi
callq 0x22330
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x223a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x22360
testb $0x1, %al
jne 0x218d8
jmp 0x21939
leaq -0x28(%rbp), %rdi
callq 0x224b0
movq (%rax), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x21923
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x22530
movq -0x58(%rbp), %rdi
movl %eax, -0x34(%rbp)
addq $0x8, %rdi
movslq -0x34(%rbp), %rsi
callq 0x22570
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x21925
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x224f0
movq %rax, -0x50(%rbp)
jmp 0x218b4
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::get_by_name2(char*)
Register *RegisterProvider::get_by_name2(char *name)
{
    Register *found = NULL;
    vector<Register *>::iterator it = registers_.begin();
    for (std::vector<Register *>::iterator x = it; x != registers_.end(); x++)
    {
        if (0 == strcmp(name, ((Register *)*x)->getName()))
        {
            int dis = distance(it, x);
            found = registers_[dis];
        }
    }
    return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x8, %rdi
callq 0x22330
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x223a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x22360
testb $0x1, %al
jne 0x21a19
jmp 0x21a94
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x224b0
movq (%rax), %rdi
callq 0x21350
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x6440
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x21a7e
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x22530
movq -0x58(%rbp), %rdi
movl %eax, -0x34(%rbp)
addq $0x8, %rdi
movslq -0x34(%rbp), %rsi
callq 0x22570
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x21a80
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x224f0
movq %rax, -0x50(%rbp)
jmp 0x219f5
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::free_by_name2(char*)
void RegisterProvider::free_by_name2(char *name)
{
    Register *found = NULL;
    vector<Register *>::iterator it = registers_.begin();
    for (std::vector<Register *>::iterator x = it; x != registers_.end(); x++)
    {
        if (0 == strcmp(name, ((Register *)*x)->getName()))
        {
            (*reservers)[(*x)->id]->pop();
            break;
            //cout << ";index: " << dis << " reg: " << registers_[dis]->getName() << endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x8, %rdi
callq 0x22330
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x223a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x22360
testb $0x1, %al
jne 0x21b59
jmp 0x21bc7
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x224b0
movq (%rax), %rdi
callq 0x21350
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x6440
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x21bb1
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x224b0
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
callq 0x223d0
movq (%rax), %rdi
callq 0x22590
jmp 0x21bc7
jmp 0x21bb3
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x224f0
movq %rax, -0x38(%rbp)
jmp 0x21b35
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::reserve()
Register *RegisterProvider::reserve()
{
    Register *found = NULL;
    vector<Register *>::iterator it = registers_.begin();
    for (std::vector<Register *>::iterator x = it; x != registers_.end(); x++)
    {
        //cout<<"bussi: "<<isBussy((*x)->id)<<" reg: "<<(*x)->getName()<<" arc: "<< getArc()<<endl;
        if (!isBussy((*x)->id) && (*x)->bits == getArc() && (*x)->reservable)
        {
            int dis = distance(it, x);
            found = registers_[dis];
            break;
            //cout << ";index: " << dis << " reg: " << registers_[dis]->getName() << endl;
        }
    }
    if (found == NULL)
    {
        found = lessBussy();
    }
    if (found == NULL)
    {
        throw "No hay Registro disponible";
    }

    (*reservers)[found->id]->push(1);
    //cout<<"top: "<<(*reservers)[found->id]->size()<<",bussy: "<<((*reservers)[found->id]->size()>0)<<",csm : "<<isBussy(found->id)<<endl;
    return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq $0x0, -0x10(%rbp)
addq $0x8, %rdi
callq 0x22330
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x223a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x22360
testb $0x1, %al
jne 0x21c68
jmp 0x21d0d
leaq -0x20(%rbp), %rdi
callq 0x224b0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %esi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %al
jne 0x21cf7
leaq -0x20(%rbp), %rdi
callq 0x224b0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x5c(%rbp)
movq (%rdi), %rax
callq *0x88(%rax)
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jne 0x21cf7
leaq -0x20(%rbp), %rdi
callq 0x224b0
movq (%rax), %rax
testb $0x1, 0x20(%rax)
je 0x21cf7
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x22530
movq -0x58(%rbp), %rdi
movl %eax, -0x2c(%rbp)
addq $0x8, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x22570
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x21d0d
jmp 0x21cf9
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x224f0
movq %rax, -0x48(%rbp)
jmp 0x21c41
cmpq $0x0, -0x10(%rbp)
jne 0x21d22
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x21d50
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x14125(%rip), %rax     # 0x35e62
movq %rax, (%rdi)
movq 0x28271(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x58(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x223d0
movq (%rax), %rdi
movl $0x1, -0x4c(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x225b0
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::reserve_by_size(int)
Register *RegisterProvider::reserve_by_size(int size)
{
    Register *found = NULL;
    vector<Register *>::iterator it = registers_.begin();
    for (std::vector<Register *>::iterator x = it; x != registers_.end(); x++)
    {
        //cout<<"bussi: "<<isBussy((*x)->id)<<" reg: "<<(*x)->getName()<<" arc: "<< getArc()<<endl;
        if (!isBussy((*x)->id)&&(*x)->reservable && (*x)->bits == size)
        {
            int dis = distance(it, x);
            found = registers_[dis];
            break;
            //cout << ";index: " << dis << " reg: " << registers_[dis]->getName() << endl;
        }
    }

    if (found == NULL)
    {
        throw "No hay Registro disponible";
    }

    (*reservers)[found->id]->push(1);
    return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x8, %rdi
callq 0x22330
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x223a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x22360
testb $0x1, %al
jne 0x220db
jmp 0x2216c
leaq -0x28(%rbp), %rdi
callq 0x224b0
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %esi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %al
jne 0x22156
leaq -0x28(%rbp), %rdi
callq 0x224b0
movq (%rax), %rax
testb $0x1, 0x20(%rax)
je 0x22156
leaq -0x28(%rbp), %rdi
callq 0x224b0
movq (%rax), %rax
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x22156
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x22530
movq -0x60(%rbp), %rdi
movl %eax, -0x34(%rbp)
addq $0x8, %rdi
movslq -0x34(%rbp), %rsi
callq 0x22570
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2216c
jmp 0x22158
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x224f0
movq %rax, -0x50(%rbp)
jmp 0x220b4
cmpq $0x0, -0x18(%rbp)
jne 0x2219a
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x13cdb(%rip), %rax     # 0x35e62
movq %rax, (%rdi)
movq 0x27e27(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x60(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x223d0
movq (%rax), %rdi
movl $0x1, -0x54(%rbp)
leaq -0x54(%rbp), %rsi
callq 0x225b0
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::get_by_size(int)
Register *RegisterProvider::get_by_size(int size)
{
    Register *found = NULL;
    vector<Register *>::iterator it = registers_.begin();
    for (std::vector<Register *>::iterator x = it; x != registers_.end(); x++)
    {
        //cout<<"bussi: "<<isBussy((*x)->id)<<" reg: "<<(*x)->getName()<<" arc: "<< getArc()<<endl;
        if ( (*x)->bits == size)
        {
            int dis = distance(it, x);
            found = registers_[dis];
            break;
            //cout << ";index: " << dis << " reg: " << registers_[dis]->getName() << endl;
        }
    }

    if (found == NULL)
    {
        throw "No hay Registro disponible";
    }

    (*reservers)[found->id]->push(1);
    return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x8, %rdi
callq 0x22330
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x223a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x22360
testb $0x1, %al
jne 0x22228
jmp 0x2228c
leaq -0x28(%rbp), %rdi
callq 0x224b0
movq (%rax), %rax
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x22276
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x22530
movq -0x60(%rbp), %rdi
movl %eax, -0x34(%rbp)
addq $0x8, %rdi
movslq -0x34(%rbp), %rsi
callq 0x22570
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2228c
jmp 0x22278
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x224f0
movq %rax, -0x50(%rbp)
jmp 0x22204
cmpq $0x0, -0x18(%rbp)
jne 0x222ba
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x13bbb(%rip), %rax     # 0x35e62
movq %rax, (%rdi)
movq 0x27d07(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x60(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x223d0
movq (%rax), %rdi
movl $0x1, -0x54(%rbp)
leaq -0x54(%rbp), %rsi
callq 0x225b0
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/backend/x86_64/x86_64.cpp
// Function: CODE_GENERATOR::x86_64::StructEq(Struct*, Struct*)
bool StructEq(Struct *o1, Struct *o2)
{
    if (o1->elemType != NULL && o2->elemType != NULL)
    {
        if (o1->kind == o2->kind)
        {
            StructEq(o1->elemType, o2->elemType);
        }
        else
        {
            return false;
        }
    }
    else
    {
        if (o1->elemType == NULL && o2->elemType != NULL)
        {
            return false;
        }
        else if (o2->elemType == NULL && o1->elemType != NULL)
        {
            return false;
        }
        return o1->kind == o2->kind;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2c2c5
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2c2c5
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x2c2bd
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2c270
jmp 0x2c2c3
movb $0x0, -0x1(%rbp)
jmp 0x2c319
jmp 0x2c317
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x2c2e1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2c2e1
movb $0x0, -0x1(%rbp)
jmp 0x2c319
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x2c2fd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2c2fd
movb $0x0, -0x1(%rbp)
jmp 0x2c319
jmp 0x2c2ff
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2c319
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/backend/x86_64/x86_64.cpp
// Function: CODE_GENERATOR::x86_64::StatementBlockNode::load(int)
void StatementBlockNode::load(int R)
{

    for (int x = 0; x < s; x++)
    {
        //cout<<stms[x]<<endl;
        stms[x]->load(1);
        if (!stms[x]->obj->_extern)
            cout << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x2c72e
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *(%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x28(%rax)
jne 0x2c721
movq 0x1d8bb(%rip), %rdi     # 0x49fd0
movq 0x1d894(%rip), %rsi     # 0x49fb0
callq 0x6320
jmp 0x2c723
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2c6ce
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/backend/x86_64/x86_64.cpp
// Function: CODE_GENERATOR::x86_64::x86_64Linux::GenerateCode(NODE*, ExternSymbols*, StringLiterals*)
void x86_64Linux::GenerateCode(AST A, ExternSymbols *es, StringLiterals *sl)
{
    cout << ";-----------------------------" << endl;
    cout << "section .data" << endl;
    sl->dump();
    cout << "formato db \"%d\",10,0" << endl;
    cout << "formato_real db \"%f\",10,0" << endl;
    cout << "formato_string db \"%s\",0" << endl;
    cout << "formato_char db \"%c\",10,0" << endl;
    cout << "" << endl;
    cout << "section .text" << endl;
    cout << "global main" << endl;
    cout << "extern printf" << endl;
    es->dump();
    cout << "" << endl;

    A->load(1);
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq 0x1d5e1(%rip), %rdi     # 0x49fd0
leaq 0x95ac(%rip), %rsi      # 0x35fa2
callq 0x62c0
movq %rax, %rdi
movq 0x1d5ab(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x1d5bf(%rip), %rdi     # 0x49fd0
leaq 0x9129(%rip), %rsi      # 0x35b41
callq 0x62c0
movq %rax, %rdi
movq 0x1d589(%rip), %rsi     # 0x49fb0
callq 0x6320
movq -0x20(%rbp), %rdi
callq 0x2cc90
movq 0x1d594(%rip), %rdi     # 0x49fd0
leaq 0x957e(%rip), %rsi      # 0x35fc1
callq 0x62c0
movq %rax, %rdi
movq 0x1d55e(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x1d572(%rip), %rdi     # 0x49fd0
leaq 0x9571(%rip), %rsi      # 0x35fd6
callq 0x62c0
movq %rax, %rdi
movq 0x1d53c(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x1d550(%rip), %rdi     # 0x49fd0
leaq 0x9569(%rip), %rsi      # 0x35ff0
callq 0x62c0
movq %rax, %rdi
movq 0x1d51a(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x1d52e(%rip), %rdi     # 0x49fd0
leaq 0x9560(%rip), %rsi      # 0x36009
callq 0x62c0
movq %rax, %rdi
movq 0x1d4f8(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x1d50c(%rip), %rdi     # 0x49fd0
leaq 0x90a2(%rip), %rsi      # 0x35b6d
callq 0x62c0
movq %rax, %rdi
movq 0x1d4d6(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x1d4ea(%rip), %rdi     # 0x49fd0
leaq 0x9046(%rip), %rsi      # 0x35b33
callq 0x62c0
movq %rax, %rdi
movq 0x1d4b4(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x1d4c8(%rip), %rdi     # 0x49fd0
leaq 0x9514(%rip), %rsi      # 0x36023
callq 0x62c0
movq %rax, %rdi
movq 0x1d492(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x1d4a6(%rip), %rdi     # 0x49fd0
leaq 0x94fe(%rip), %rsi      # 0x3602f
callq 0x62c0
movq %rax, %rdi
movq 0x1d470(%rip), %rsi     # 0x49fb0
callq 0x6320
movq -0x18(%rbp), %rdi
callq 0x2ce00
movq 0x1d47b(%rip), %rdi     # 0x49fd0
leaq 0x9011(%rip), %rsi      # 0x35b6d
callq 0x62c0
movq %rax, %rdi
movq 0x1d445(%rip), %rsi     # 0x49fb0
callq 0x6320
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *(%rax)
leaq 0x7a29(%rip), %rdi      # 0x345ae
movb $0x0, %al
callq 0x6070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit(LEAF::AST::BinOp*)
void x86_64_linux_generator_visitor::visit(BinOp *bin)
{
    UPDATE_STATICS

    bin->l->accept(this);
    Register *current = this->reg;

    reg = rp->reserve();
    bin->r->accept1(this);

    this->op_reg = reg;
    reg = current;
    this->ax = bin->op;
    bin->r->accept2(this);

    rp->free(op_reg->id);
    this->ax = Load;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movl 0x8(%rsi), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsi)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq -0x20(%rbp), %rsi
movq %rax, 0x20(%rsi)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rsi
movq 0x20(%rsi), %rax
movq %rax, 0x28(%rsi)
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rsi)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x38(%rsi)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x28(%rax), %rax
movl (%rax), %esi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit2(LEAF::AST::BinOp*)
void x86_64_linux_generator_visitor::visit2(BinOp *bin)
{
    UPDATE_STATICS
    Section *st = assembly->get_program()->section(Sections::text);
    if (this->ax == Store)
        throw "can´t store here";
    if (this->ax == Plus)
    {
        DInstruccion *i = new DInstruccion("add");

        i->add_operand(new RegisterOperand(reg->getName()));
        i->add_operand(new RegisterOperand(op_reg->getName()));
        st->add(i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rdi
callq 0xb010
movq %rax, %rdi
movl $0x2, %esi
callq 0x1c3c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
cmpl $0x0, 0x38(%rax)
jne 0x2e3ef
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x7d92(%rip), %rax      # 0x3616e
movq %rax, (%rdi)
movq 0x1bbd2(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x38(%rbp), %rax
cmpl $0x2, 0x38(%rax)
jne 0x2e51f
movl $0x28, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x7d68(%rip), %rsi      # 0x36180
callq 0x1a4e0
jmp 0x2e41f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x10, %edi
callq 0x62e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq 0x20(%rax), %rdi
callq 0x21350
movq %rax, -0x48(%rbp)
jmp 0x2e453
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x1b1e0
jmp 0x2e462
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x10, %edi
callq 0x62e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq 0x28(%rax), %rdi
callq 0x21350
movq %rax, -0x60(%rbp)
jmp 0x2e49f
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x1b1e0
jmp 0x2e4ae
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x18670
jmp 0x2e51f
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0x62f0
jmp 0x2e525
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x62f0
jmp 0x2e525
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x62f0
jmp 0x2e525
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nop
// File: Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit(LEAF::AST::BlockStatemntNode*)
void x86_64_linux_generator_visitor::visit(BlockStatemntNode *block)
{
    UPDATE_STATICS
    //cout<<"block load : "<<block->s<<endl;

    vector<ASTU>::iterator x = block->nodos.begin();
    for (; x != block->nodos.end(); x++)
    {
        (*x)->accept(this);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0xdd70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0xdc00
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x31da0
testb $0x1, %al
jne 0x2eca6
jmp 0x2eccc
leaq -0x18(%rbp), %rdi
callq 0x31de0
movq -0x30(%rbp), %rsi
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x31e00
movq %rax, -0x28(%rbp)
jmp 0x2ec82
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit(LEAF::AST::AssignStatement*)
void x86_64_linux_generator_visitor::visit(AssignStatement *as)
{
    UPDATE_STATICS

    Section *st = assembly->get_program()->section(Sections::text);
    Register *current_reg = this->reg;
    
    this->ax = Load;
    as->right->accept(this);
    this->ax = Store;
    as->left->accept2(this);
    // rp->free(reg->id);
    this->ax = Load;
    
    this->reg = current_reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rdi
callq 0xb010
movq %rax, %rdi
movl $0x2, %esi
callq 0x1c3c0
movq -0x28(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq 0x20(%rsi), %rax
movq %rax, -0x20(%rbp)
movl $0x1, 0x38(%rsi)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x28(%rbp), %rsi
movl $0x0, 0x38(%rsi)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit(LEAF::AST::FloatConst*)
void x86_64_linux_generator_visitor::visit(FloatConst *number)
{
    UPDATE_STATICS
    if (!number->in_data)
    {
        string *label_data = new string(number->adr_label->c_str());
        label_data->append(" dq ");
        char *chars_val = new char[20];
        sprintf(chars_val, "%.7lf", number->value);
        label_data->append(chars_val);
        assembly->get_program()->section(Sections::data)->add(new RegisterOperand(label_data->c_str()));
        number->in_data = true;
    }
    this->reg = this->rp->reserve_by_size(128);
    number->accept2(this);
    rp->free(this->reg->id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x30(%rax)
jne 0x2f8fc
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movb $0x1, -0x2d(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x6120
movq %rax, -0x50(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x6500
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xada0
jmp 0x2f7f9
movb $0x0, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x6986(%rip), %rsi      # 0x3619f
callq 0x6540
movl $0x14, %edi
callq 0x6040
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movss 0x24(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x6960(%rip), %rsi      # 0x361a4
movb $0x1, %al
callq 0x60a0
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6540
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb010
movq %rax, %rdi
xorl %esi, %esi
callq 0x1c3c0
movq %rax, -0x78(%rbp)
movl $0x10, %edi
callq 0x62e0
movq %rax, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6120
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x1b1e0
jmp 0x2f89c
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x18670
movq -0x10(%rbp), %rax
movb $0x1, 0x30(%rax)
jmp 0x2f8fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
testb $0x1, -0x2d(%rbp)
jne 0x2f8d0
jmp 0x2f8de
movq -0x60(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0x2f93e
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x62f0
jmp 0x2f93e
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
movl $0x80, %esi
callq *0x78(%rax)
movq -0x40(%rbp), %rsi
movq %rax, 0x20(%rsi)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x20(%rax), %rax
movl (%rax), %esi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nopw (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/feactures/class/class_handler.cpp
// Function: LEAF::FEACTURE::CLASS::ClassHandler::draw(std::vector<LEAF::HELPER::GRAPH::Edge*, std::allocator<LEAF::HELPER::GRAPH::Edge*>>*)
void ClassHandler::draw(vector<Edge *> *list)
{
    string st("");
    vector<Edge *>::iterator x = list->begin();
    for (; x != list->end(); x++)
    {
        st.append(" ");
        st.append((*x)->nodea->name->c_str());
        if ((*x)->rel == IMPLEMENT)
        {
            st.append(" --> ");
        }
        else
        {
            st.append(" > ");
        }
        st.append((*x)->nodeb->name->c_str());
        st.append(",");
    }
    cout << st << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6500
movq -0x68(%rbp), %rdx
leaq 0x39e5(%rip), %rsi      # 0x35b6d
leaq -0x30(%rbp), %rdi
callq 0xada0
jmp 0x32193
leaq -0x31(%rbp), %rdi
callq 0x6340
movq -0x10(%rbp), %rdi
callq 0x32bc0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32c30
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x32bf0
testb $0x1, %al
jne 0x321cc
jmp 0x322bf
leaq 0x2826(%rip), %rsi      # 0x349f9
leaq -0x30(%rbp), %rdi
callq 0x6540
jmp 0x321de
leaq -0x50(%rbp), %rdi
callq 0x32c60
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x6120
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x6540
jmp 0x32203
leaq -0x50(%rbp), %rdi
callq 0x32c60
movq (%rax), %rax
cmpl $0x1, 0x10(%rax)
jne 0x3225d
leaq 0x4088(%rip), %rsi      # 0x362a4
leaq -0x30(%rbp), %rdi
callq 0x6540
jmp 0x32227
jmp 0x32271
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x6340
jmp 0x322f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6588
jmp 0x322f6
leaq 0x4046(%rip), %rsi      # 0x362aa
leaq -0x30(%rbp), %rdi
callq 0x6540
jmp 0x3226f
jmp 0x32271
leaq -0x50(%rbp), %rdi
callq 0x32c60
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x6120
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x6540
jmp 0x32297
leaq 0x38d0(%rip), %rsi      # 0x35b6e
leaq -0x30(%rbp), %rdi
callq 0x6540
jmp 0x322a9
jmp 0x322ab
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x32c80
movq %rax, -0x60(%rbp)
jmp 0x321a9
movq 0x17d0a(%rip), %rdi     # 0x49fd0
leaq -0x30(%rbp), %rsi
callq 0x6280
movq %rax, -0x70(%rbp)
jmp 0x322d5
movq -0x70(%rbp), %rdi
movq 0x17cd0(%rip), %rsi     # 0x49fb0
callq 0x6320
jmp 0x322e7
leaq -0x30(%rbp), %rdi
callq 0x6588
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x64f0
nop
// File: Davidc2525[P]Leaf/compiler/feactures/class/class_handler.cpp
// Function: LEAF::FEACTURE::CLASS::ClassHandler::implement(LEAF::HELPER::GRAPH::Node*, LEAF::HELPER::GRAPH::Node*)
void ClassHandler::implement(Node *a, Node *b)
{
    if (a->type == CLASS && b->type == INTERFACE)
    {
    }
    else
    {
        if (b->type == CLASS)
        {
            cout << "no puede implementar una clase: " << *a->name << " implement " << *b->name << "(class)" << endl;
        }
        cout << "no puede implementar: " << *a->name << " -> " << *b->name << endl;
        return;
    }
    if (this->check_implement(a, b))
    {
        this->add(new Edge(a, b, IMPLEMENT));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x32335
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x32335
jmp 0x323ee
movq -0x18(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x3239d
movq 0x17c8a(%rip), %rdi     # 0x49fd0
leaq 0x3f61(%rip), %rsi      # 0x362ae
callq 0x62c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x6280
movq %rax, %rdi
leaq 0x3f64(%rip), %rsi      # 0x362cf
callq 0x62c0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6280
movq %rax, %rdi
leaq 0x3f52(%rip), %rsi      # 0x362db
callq 0x62c0
movq %rax, %rdi
movq 0x17c18(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x17c2c(%rip), %rdi     # 0x49fd0
leaq 0x3f38(%rip), %rsi      # 0x362e3
callq 0x62c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x6280
movq %rax, %rdi
leaq 0x3f31(%rip), %rsi      # 0x362fa
callq 0x62c0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6280
movq %rax, %rdi
movq 0x17bc9(%rip), %rsi     # 0x49fb0
callq 0x6320
jmp 0x32458
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x32470
testb $0x1, %al
jne 0x32405
jmp 0x32458
movl $0x18, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x32df0
jmp 0x3242d
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x32f00
jmp 0x32458
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x62f0
jmp 0x3245e
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x64f0
nopw (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/feactures/class/class_handler.cpp
// Function: LEAF::FEACTURE::CLASS::ClassHandler::check_implement(LEAF::HELPER::GRAPH::Node*, LEAF::HELPER::GRAPH::Node*)
bool ClassHandler::check_implement(Node *a, Node *b)
{

    if (0 == strcmp(a->name->c_str(), b->name->c_str()))
    {
        throw "no se puede implementar asi misma";
    }

    if (this->cyclic(b, a))
    {
        throw "cyclic error (I)";
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6120
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x6120
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x6440
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x324e3
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x3e42(%rip), %rax      # 0x36312
movq %rax, (%rdi)
movq 0x17ade(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x32760
testb $0x1, %al
jne 0x324fa
jmp 0x32521
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x3e26(%rip), %rax      # 0x36334
movq %rax, (%rdi)
movq 0x17aa0(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/feactures/class/class_handler.cpp
// Function: LEAF::FEACTURE::CLASS::ClassHandler::extend(LEAF::HELPER::GRAPH::Node*, LEAF::HELPER::GRAPH::Node*)
void ClassHandler::extend(Node *a, Node *b)
{
    if (a->type == CLASS && b->type == CLASS)
    {
    }
    else
    {
        if (b->type == CLASS)
        {
            cout << "no puede heredar: " << *a->name << " -> " << *b->name << "(class)" << endl;
        }
        cout << "no puede heredar: " << *a->name << " -> " << *b->name << endl;
        return;
    }
    if (this->check_hierarchy(a, b))
    {
        this->add(new Edge(a, b, HIERARCHY));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x32565
movq -0x18(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x32565
jmp 0x3261e
movq -0x18(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x325cd
movq 0x17a5a(%rip), %rdi     # 0x49fd0
leaq 0x3d82(%rip), %rsi      # 0x362ff
callq 0x62c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x6280
movq %rax, %rdi
leaq 0x3d5f(%rip), %rsi      # 0x362fa
callq 0x62c0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6280
movq %rax, %rdi
leaq 0x3d22(%rip), %rsi      # 0x362db
callq 0x62c0
movq %rax, %rdi
movq 0x179e8(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x179fc(%rip), %rdi     # 0x49fd0
leaq 0x3d24(%rip), %rsi      # 0x362ff
callq 0x62c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x6280
movq %rax, %rdi
leaq 0x3d01(%rip), %rsi      # 0x362fa
callq 0x62c0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6280
movq %rax, %rdi
movq 0x17999(%rip), %rsi     # 0x49fb0
callq 0x6320
jmp 0x32688
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x326a0
testb $0x1, %al
jne 0x32635
jmp 0x32688
movl $0x18, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x2, %ecx
callq 0x32df0
jmp 0x3265d
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x32f00
jmp 0x32688
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x62f0
jmp 0x3268e
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x64f0
nopw (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/feactures/class/class_handler.cpp
// Function: LEAF::FEACTURE::CLASS::ClassHandler::check_hierarchy(LEAF::HELPER::GRAPH::Node*, LEAF::HELPER::GRAPH::Node*)
bool ClassHandler::check_hierarchy(Node *a, Node *b)
{

    if (0 == strcmp(a->name->c_str(), b->name->c_str()))
    {
        throw "no se puede heredar asi misma";
    }

    if (this->cyclic(b, a))
    {
        throw "cyclic error";
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6120
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x6120
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x6440
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x32713
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x3c45(%rip), %rax      # 0x36345
movq %rax, (%rdi)
movq 0x178ae(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x32760
testb $0x1, %al
jne 0x3272a
jmp 0x32751
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x3c25(%rip), %rax      # 0x36363
movq %rax, (%rdi)
movq 0x17870(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/helper/graphs/graph.cpp
// Function: LEAF::HELPER::GRAPH::Graph::filter_path_from_by_nodea(LEAF::HELPER::GRAPH::Node*, std::vector<LEAF::HELPER::GRAPH::Edge*, std::allocator<LEAF::HELPER::GRAPH::Edge*>>*)
vector<Edge *> *Graph::filter_path_from_by_nodea(Node *n, vector<Edge *> *list)
{
    vector<Edge *> *rf = new vector<Edge *>;
    vector<Edge *>::iterator x = list->begin();
    for (; x != list->end(); x++)
    {

        if (0 == strcmp((*x)->nodea->name->c_str(), n->name->c_str()))
        {
            rf->push_back((*x));
        }
    }

    return rf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x32cc0
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32bc0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32c30
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32bf0
testb $0x1, %al
jne 0x32e7f
jmp 0x32eed
leaq -0x28(%rbp), %rdi
callq 0x32c60
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x6120
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6120
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x6440
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x32ed7
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x32c60
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x33070
jmp 0x32ed9
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x32c80
movq %rax, -0x38(%rbp)
jmp 0x32e5f
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)