LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/compiler/symb_tab/symbol_table.cpp
// Function: symbol_table::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
Obj *symbol_table::find(string *name)
{
    /*Obj *obj;
    Scope *scope;
    scope = curScope;
    while (scope != NULL) {  // for all open scopes
        obj = scope->locals;
        while (obj != NULL) {  // for all objects in this scope
            if (obj->name == name){
                 //cout<<" find obj: "<<obj->name<<", p: "<<obj<<endl;
                 return obj;}
            obj = obj->next;
        }
        scope = scope->outer;
    }*/
    bool ownScope = true;
    for (Scope *s = curScope; s != NULL; (s = s->outer, ownScope = false))
    {
        for (Obj *p = s->locals; p != NULL; p = p->next)
        {
            if (*p->name == *name)
            {
                /*cout<<"; find st, obj kind: "<<p->kind<<", name "<<*p->name<<", type kind: "<<p->type->kind<<endl;
                if(p->type->kind == Struct::Arr){
                    cout<<";  - elemtype kind: "<<p->type->elemType->kind<<endl;

                }*/
                //cout<<"; "<<*p->name<<" no pertenece a este ambito."<<endl;
                return p;
            }
        }
    }
    cout << "; " << *name << " is undeclared" << endl;
    return noObj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x15cd3(%rip), %r15     # 0x26d88
movq (%r15), %r15
testq %r15, %r15
je 0x11109
movq 0x8(%r15), %r12
testq %r12, %r12
sete %bpl
je 0x11103
movq 0x8(%rbx), %r13
movq 0x8(%r12), %rax
movq 0x8(%rax), %rdx
cmpq %r13, %rdx
jne 0x110f0
testq %rdx, %rdx
je 0x11100
movq (%rbx), %rsi
movq (%rax), %rdi
callq 0x52b0
testl %eax, %eax
je 0x11100
movq 0x20(%r12), %r12
testq %r12, %r12
sete %bpl
jne 0x110ce
jmp 0x11103
movq %r12, %r14
testb $0x1, %bpl
jne 0x110b5
testq %r15, %r15
jne 0x1117d
movq 0x14ec3(%rip), %r14     # 0x25fd8
leaq 0x8b70(%rip), %rsi      # 0x19c8c
movl $0x2, %edx
movq %r14, %rdi
callq 0x5300
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %rbx
leaq 0x9e6c(%rip), %rsi      # 0x1afae
movl $0xe, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0x15c8b(%rip), %r14     # 0x26e08
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/compiler/symb_tab/symbol_table.cpp
// Function: symbol_table::findField(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, Struct*)
Obj *symbol_table::findField(string *name, Struct *t)
{

    for (Obj *p = t->fields; p != NULL; p = p->next)
    {
        if (*p->name == *name)
            return p;
    }

    cout << "; " << *name << " field is undeclared" << endl;
    return symbol_table::noObj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rsi), %r14
testq %r14, %r14
sete %bpl
je 0x111e1
movq 0x8(%rbx), %r15
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdx
cmpq %r15, %rdx
jne 0x111cc
testq %rdx, %rdx
je 0x111db
movq (%rbx), %rsi
movq (%rax), %rdi
callq 0x52b0
testl %eax, %eax
je 0x111db
movq 0x20(%r14), %r14
testq %r14, %r14
sete %bpl
jne 0x111ab
jmp 0x111e1
testb $0x1, %bpl
je 0x11250
movq 0x14df0(%rip), %r14     # 0x25fd8
leaq 0x8a9d(%rip), %rsi      # 0x19c8c
movl $0x2, %edx
movq %r14, %rdi
callq 0x5300
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %rbx
leaq 0x9d93(%rip), %rsi      # 0x1afa8
movl $0x14, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0x15bb8(%rip), %r14     # 0x26e08
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/compiler/symb_tab/symbol_table.cpp
// Function: symbol_table::openScope()
void symbol_table::openScope()
{
    Scope *s = new Scope();
    s->level = curLevel;
    s->outer = curScope;
    curScope = s;
    curLevel++;
}

// Assembly:
pushq %rax
movl $0x20, %edi
callq 0x5290
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x8, 0x10(%rax)
movl $0x0, 0x18(%rax)
movl 0x15b09(%rip), %ecx     # 0x26d90
movl %ecx, 0x18(%rax)
movq 0x15af7(%rip), %rdx     # 0x26d88
movq %rdx, (%rax)
movq %rax, 0x15aed(%rip)     # 0x26d88
incl %ecx
movl %ecx, 0x15aed(%rip)     # 0x26d90
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x20, %edi
callq 0x5290
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x9645(%rip), %rsi      # 0x1afe5
leaq 0x9648(%rip), %rdx      # 0x1afef
movq %rbx, %rdi
callq 0x84ba
leaq 0x963a(%rip), %rsi      # 0x1aff0
movq %rbx, %rdi
callq 0x54b0
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x54b0
leaq 0x9623(%rip), %rsi      # 0x1aff7
movq %rbx, %rdi
callq 0x54b0
movl 0x10(%r14), %r12d
movl %r12d, %ebp
negl %ebp
cmovsl %r12d, %ebp
movl $0x1, %r14d
cmpl $0xa, %ebp
jb 0x11a3d
movl $0x4, %r14d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x11a34
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x11a3a
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x11a3d
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r14d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x11a01
addl $-0x3, %r14d
jmp 0x11a3d
addl $-0x2, %r14d
jmp 0x11a3d
decl %r14d
shrl $0x1f, %r12d
movl %r12d, %esi
addl %r14d, %esi
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x2d, %edx
callq 0x5310
movq (%r15), %rdi
addq %r12, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x7d81
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x50f0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11a98
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52a0
leaq 0x9560(%rip), %rsi      # 0x1afff
movq %rbx, %rdi
callq 0x54b0
movq (%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11ae0
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x11adb
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, (%rdi)
setg %r15b
jle 0x11b9b
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
cmpl %ebp, %eax
jne 0x11ba0
xorl %r12d, %r12d
jmp 0x11bd0
xorl %r14d, %r14d
jmp 0x11bd8
movl $0x1, %r12d
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r12
setl %r15b
jge 0x11bd8
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
incq %r12
cmpl %ebp, %eax
jne 0x11ba9
decq %r12
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %r14
testb %r15b, %r15b
jne 0x11be2
testq %r14, %r14
je 0x11bee
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x5140
leaq 0x9402(%rip), %rcx      # 0x1b001
movq %rcx, (%rax)
movq 0x143bf(%rip), %rsi     # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
cmpq 0x10(%rdi), %r15
je 0x11f51
xorl %r14d, %r14d
movabsq $0x100000000, %r13      # imm = 0x100000000
xorl %r12d, %r12d
movq (%r15), %rax
movl (%rax), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testb %al, %al
jne 0x11f42
movq (%r15), %rax
movl 0x10(%rax), %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x88(%rax)
cmpl %eax, %ebp
jne 0x11f42
movq (%r15), %rax
cmpb $0x1, 0x20(%rax)
je 0x11f56
addq $0x8, %r15
addq %r13, %r12
cmpq 0x10(%rbx), %r15
jne 0x11f12
jmp 0x11f62
xorl %r14d, %r14d
jmp 0x11f62
movq 0x8(%rbx), %rax
sarq $0x1d, %r12
movq (%rax,%r12), %r14
testq %r14, %r14
jne 0x11f73
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq %rax, %r14
testq %r14, %r14
je 0x11fa9
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x122c0
movq (%rax), %rdi
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
callq 0x12576
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x5140
leaq 0x9088(%rip), %rcx      # 0x1b042
movq %rcx, (%rax)
movq 0x14004(%rip), %rsi     # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq 0x10(%rdi), %r15
je 0x1219b
movl %esi, %ebp
xorl %ebx, %ebx
movabsq $0x100000000, %r13      # imm = 0x100000000
xorl %r12d, %r12d
movq (%r15), %rax
movl (%rax), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
testb %al, %al
jne 0x1218c
movq (%r15), %rax
cmpb $0x1, 0x20(%rax)
jne 0x1218c
cmpl %ebp, 0x10(%rax)
je 0x1219f
addq $0x8, %r15
addq %r13, %r12
cmpq 0x10(%r14), %r15
jne 0x1216d
jmp 0x121ab
xorl %ebx, %ebx
jmp 0x121ab
movq 0x8(%r14), %rax
sarq $0x1d, %r12
movq (%rax,%r12), %rbx
testq %rbx, %rbx
je 0x121e1
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x122c0
movq (%rax), %rdi
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
callq 0x12576
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x5140
leaq 0x8e50(%rip), %rcx      # 0x1b042
movq %rcx, (%rax)
movq 0x13dcc(%rip), %rsi     # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/compiler/backend/x86_64/x86_64.cpp
// Function: CODE_GENERATOR::x86_64::DeclFuncNode::load(int)
void DeclFuncNode::load(int R)
{
    RegisterProvider *rp = RegisterManager::getInstance()->getProviderBy(64);

    loadOpt->effectivea->parts.push_back(new EffectivePart(rp->reserve_by_size(128)->id));
    loadOpt->effectivea->parts.push_back(new EffectivePart(rp->reserve_by_size(32)->id));
    loadOpt->effectivea->parts.push_back(new EffectivePart(8, Num, Mul));
    loadOpt->effectivea->parts.push_back(new EffectivePart(8, Num, Mul));

    cout << "funcion: " << *name << " '" << loadOpt->effectivea->toString() << "'" << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x11b02
movq %rax, %rdi
movl $0x40, %esi
callq 0x11b6c
movq %rax, %r14
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r12
movl $0xc, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
movl $0x80, %esi
callq *0x78(%rax)
movl (%rax), %esi
movq %r15, %rdi
callq 0x10830
addq $0x8, %r12
movq %rsp, %rsi
movq %r15, (%rsi)
movq %r12, %rdi
callq 0x15de2
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r12
movl $0xc, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
movl $0x20, %esi
callq *0x78(%rax)
movl (%rax), %esi
movq %r15, %rdi
callq 0x10830
addq $0x8, %r12
movq %rsp, %rsi
movq %r15, (%rsi)
movq %r12, %rdi
callq 0x15de2
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r15
movl $0xc, %edi
callq 0x5290
movq %rax, %r14
movq %rax, %rdi
movl $0x8, %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x10858
addq $0x8, %r15
movq %rsp, %rsi
movq %r14, (%rsi)
movq %r15, %rdi
callq 0x15de2
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r15
movl $0xc, %edi
callq 0x5290
movq %rax, %r14
movq %rax, %rdi
movl $0x8, %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x10858
addq $0x8, %r15
movq %rsp, %rsi
movq %r14, (%rsi)
movq %r15, %rdi
callq 0x15de2
movq 0x10bb1(%rip), %r14     # 0x25fd8
leaq 0x5d62(%rip), %rsi      # 0x1b190
movl $0x9, %edx
movq %r14, %rdi
callq 0x5300
movq 0x50(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %r14
leaq 0x5d42(%rip), %rsi      # 0x1b19a
movl $0x2, %edx
movq %rax, %rdi
callq 0x5300
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x1087a
testq %rax, %rax
je 0x15492
movq %rax, %rbx
movq %rax, %rdi
callq 0x5120
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x5300
jmp 0x154ac
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x5440
leaq 0x5ce8(%rip), %rsi      # 0x1b19b
movl $0x1, %edx
movq %r14, %rdi
callq 0x5300
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r14, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x154f5
movq %rax, %rbx
movl $0xc, %esi
movq %r14, %rdi
jmp 0x1550f
jmp 0x15504
movq %rax, %rbx
movl $0xc, %esi
movq %r15, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x48(%rdi)
jle 0x1560e
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x10a26(%rip), %r14     # 0x25fd8
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *(%rax)
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
cmpb $0x0, 0x28(%rax)
jne 0x155fd
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r14, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
incq %r15
movslq 0x48(%rbx), %rax
cmpq %rax, %r15
jl 0x155b2
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
incl 0x8(%rdi)
movq %rsi, %r14
movq 0x28(%rsi), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq 0x20(%rbx), %r15
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, 0x20(%rbx)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
movq %r15, 0x20(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rdi
movl (%rax), %esi
movq (%rdi), %rax
callq *0x28(%rax)
movl $0x1, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
incl 0x8(%rdi)
movq 0x10(%rdi), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x102f0
movq %rax, %rbx
movl 0x38(%r15), %eax
cmpl $0x2, %eax
je 0x16339
testl %eax, %eax
je 0x163c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x5290
movq %rax, %r14
leaq 0x502e(%rip), %rsi      # 0x1b37b
movq %rax, %rdi
callq 0xfc18
movl $0x10, %edi
callq 0x5290
movq %rax, %r12
movq 0x20(%r15), %rdi
callq 0x1196c
movq %r12, %rdi
movq %rax, %rsi
callq 0xfe4e
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
movl $0x10, %edi
callq 0x5290
movq %rax, %r12
movq 0x28(%r15), %rdi
callq 0x1196c
movq %r12, %rdi
movq %rax, %rsi
callq 0xfe4e
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf258
movl $0x8, %edi
callq 0x5140
leaq 0x4f93(%rip), %rcx      # 0x1b369
movq %rcx, (%rax)
movq 0xfbe8(%rip), %rsi      # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
jmp 0x16404
jmp 0x163f9
movq %rax, %rbx
movl $0x10, %esi
movq %r12, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
incl 0x8(%rdi)
movq 0x28(%rsi), %r15
cmpq 0x30(%rsi), %r15
je 0x16779
movq %rdi, %rbx
movq %rsi, %r14
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r15
cmpq 0x30(%r14), %r15
jne 0x16764
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x8(%rdi)
movq %rsi, %r14
movq 0x10(%rdi), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x102f0
movq 0x20(%rbx), %r15
movl $0x1, %ebp
movl %ebp, 0x38(%rbx)
movq 0x28(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movl $0x0, 0x38(%rbx)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movl %ebp, 0x38(%rbx)
movq %r15, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit2(LEAF::AST::IntConst*)
void x86_64_linux_generator_visitor::visit2(IntConst *number)
{
    UPDATE_STATICS
    Section *st = assembly->get_program()->section(Sections::text);
    if (this->ax == Load)
    {
        DInstruccion *i = new DInstruccion("mov");
        InmediateIntOperand *ops = new InmediateIntOperand(number->value);
        RegisterOperand *opd = new RegisterOperand(this->reg->getName());
        i->add_operand(opd);
        i->add_operand(ops);
        st->add(i);
    }

    if (this->ax == op_types::Plus)
    {
        DInstruccion *i = new DInstruccion("add");
        InmediateIntOperand *ops = new InmediateIntOperand(number->value);
        RegisterOperand *opd = new RegisterOperand(this->reg->getName());
        i->add_operand(opd);
        i->add_operand(ops);
        st->add(i);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
incl 0x8(%rdi)
movq %rsi, %r15
movq 0x10(%rdi), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x102f0
movq %rax, %rbx
cmpl $0x1, 0x38(%r14)
jne 0x16bee
movl $0x28, %edi
callq 0x5290
movq %rax, %r12
leaq 0x47fd(%rip), %rsi      # 0x1b384
movq %rax, %rdi
callq 0xfc18
movl $0x10, %edi
callq 0x5290
movq %rax, %r13
movl 0x24(%r15), %esi
movq %rax, %rdi
callq 0xfe14
movl $0x10, %edi
callq 0x5290
movq %rax, %rbp
movq 0x20(%r14), %rdi
callq 0x1196c
movq %rbp, %rdi
movq %rax, %rsi
callq 0xfe4e
movq (%r12), %rax
movq %r12, %rdi
movq %rbp, %rsi
callq *0x20(%rax)
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x20(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf258
cmpl $0x2, 0x38(%r14)
jne 0x16c82
movl $0x28, %edi
callq 0x5290
movq %rax, %r12
leaq 0x476e(%rip), %rsi      # 0x1b37b
movq %rax, %rdi
callq 0xfc18
movl $0x10, %edi
callq 0x5290
movq %rax, %r13
movl 0x24(%r15), %esi
movq %rax, %rdi
callq 0xfe14
movl $0x10, %edi
callq 0x5290
movq %rax, %r15
movq 0x20(%r14), %rdi
callq 0x1196c
movq %r15, %rdi
movq %rax, %rsi
callq 0xfe4e
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x20(%rax)
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x20(%rax)
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf258
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16c95
jmp 0x16ca2
movq %rax, %rbx
movl $0x10, %esi
movq %r13, %rdi
jmp 0x16cc7
movq %rax, %rbx
movl $0x28, %esi
movq %r12, %rdi
jmp 0x16cc7
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
jmp 0x16cc7
movq %rax, %rbx
movl $0x10, %esi
movq %rbp, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
incl 0x8(%rdi)
movq %rsi, %r14
cmpb $0x0, 0x30(%rsi)
jne 0x16d8c
movl $0x20, %edi
callq 0x5290
movq %rax, %r15
movq 0x28(%r14), %rax
movq (%rax), %rsi
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0xe90c
leaq 0x467e(%rip), %rsi      # 0x1b39a
movq %r15, %rdi
callq 0x54b0
movl $0x14, %edi
callq 0x5040
movq %rax, %r12
cvtss2sd 0x24(%r14), %xmm0
leaq 0x4661(%rip), %rsi      # 0x1b39f
movq %rax, %rdi
movb $0x1, %al
callq 0x5090
movq %r15, %rdi
movq %r12, %rsi
callq 0x54b0
movq 0x10(%rbx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x102f0
movq %rax, %r13
movl $0x10, %edi
callq 0x5290
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
callq 0xfe4e
movq %r13, %rdi
movq %r12, %rsi
callq 0xf258
movb $0x1, 0x30(%r14)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movl $0x80, %esi
callq *0x78(%rax)
movq %rax, 0x20(%rbx)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq 0x20(%rbx), %rax
movq 0x30(%rbx), %rdi
movl (%rax), %esi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r12, %rdi
jmp 0x16de1
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2e66(%rip), %rdx      # 0x1ad27
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x84ba
movq (%rbx), %rbp
cmpq 0x8(%rbx), %rbp
je 0x17f5b
leaq 0x8(%rsp), %r15
leaq 0x35b8(%rip), %r13      # 0x1b49f
leaq 0x35b7(%rip), %r14      # 0x1b4a5
leaq 0x2e33(%rip), %r12      # 0x1ad28
movq %r15, %rdi
leaq 0x1cf2(%rip), %rsi      # 0x19bf1
callq 0x54b0
movq (%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x54b0
movq (%rbp), %rax
cmpl $0x1, 0x10(%rax)
movq %r14, %rsi
cmoveq %r13, %rsi
movq %r15, %rdi
callq 0x54b0
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x54b0
movq %r15, %rdi
movq %r12, %rsi
callq 0x54b0
addq $0x8, %rbp
cmpq 0x8(%rbx), %rbp
jne 0x17ef5
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0xe06c(%rip), %rdi      # 0x25fd8
callq 0x5300
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x17fb7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17fc8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x17fe7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x2, 0x8(%rsi)
jne 0x1804e
cmpl $0x1, 0x8(%rbx)
jne 0x1804e
movq %rdi, %r15
movq %r14, %rsi
movq %rbx, %rdx
callq 0x18190
movl $0x18, %edi
callq 0x5290
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x187a4
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18832
cmpl $0x2, 0x8(%rbx)
jne 0x180ec
movq 0xdf79(%rip), %r15      # 0x25fd8
leaq 0x3443(%rip), %rsi      # 0x1b4a9
movl $0x20, %edx
movq %r15, %rdi
callq 0x5300
movq (%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r15
leaq 0x343b(%rip), %rsi      # 0x1b4ca
movl $0xb, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r15
leaq 0x341e(%rip), %rsi      # 0x1b4d6
movl $0x7, %edx
movq %rax, %rdi
callq 0x5300
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r15, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0xdee5(%rip), %r15      # 0x25fd8
leaq 0x33e4(%rip), %rsi      # 0x1b4de
movl $0x16, %edx
movq %r15, %rdi
callq 0x5300
movq (%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r14
leaq 0x33d2(%rip), %rsi      # 0x1b4f5
movl $0x4, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51a0
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq (%rax), %rdi
movq (%rdx), %rax
movq (%rax), %rsi
callq 0x53a0
testl %eax, %eax
je 0x181cd
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1841c
testb %al, %al
jne 0x181e0
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x5140
leaq 0x332f(%rip), %rcx      # 0x1b50d
jmp 0x181f1
movl $0x8, %edi
callq 0x5140
leaq 0x333e(%rip), %rcx      # 0x1b52f
movq %rcx, (%rax)
movq 0xddcd(%rip), %rsi      # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x2, 0x8(%rsi)
jne 0x18264
cmpl $0x2, 0x8(%rbx)
jne 0x18264
movq %rdi, %r15
movq %r14, %rsi
movq %rbx, %rdx
callq 0x183a6
movl $0x18, %edi
callq 0x5290
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x2, %ecx
callq 0x187a4
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18832
cmpl $0x2, 0x8(%rbx)
jne 0x18302
movq 0xdd63(%rip), %r15      # 0x25fd8
leaq 0x327e(%rip), %rsi      # 0x1b4fa
movl $0x12, %edx
movq %r15, %rdi
callq 0x5300
movq (%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r15
leaq 0x3250(%rip), %rsi      # 0x1b4f5
movl $0x4, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r15
leaq 0x3208(%rip), %rsi      # 0x1b4d6
movl $0x7, %edx
movq %rax, %rdi
callq 0x5300
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r15, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0xdccf(%rip), %r15      # 0x25fd8
leaq 0x31ea(%rip), %rsi      # 0x1b4fa
movl $0x12, %edx
movq %r15, %rdi
callq 0x5300
movq (%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r14
leaq 0x31bc(%rip), %rsi      # 0x1b4f5
movl $0x4, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51a0
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq (%rax), %rdi
movq (%rdx), %rax
movq (%rax), %rsi
callq 0x53a0
testl %eax, %eax
je 0x183e3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1841c
testb %al, %al
jne 0x183f6
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x5140
leaq 0x314c(%rip), %rcx      # 0x1b540
jmp 0x18407
movl $0x8, %edi
callq 0x5140
leaq 0x3157(%rip), %rcx      # 0x1b55e
movq %rcx, (%rax)
movq 0xdbb7(%rip), %rsi      # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl $0x18, %edi
callq 0x5290
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0x18825
movq (%r12), %r13
movq (%r13), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq (%r14), %rax
movq (%rax), %rsi
callq 0x53a0
testl %eax, %eax
jne 0x1881f
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0x18814
movq %r13, (%rsi)
addq $0x8, 0x8(%r15)
jmp 0x1881f
movq %r15, %rdi
movq %r12, %rdx
callq 0x1891e
addq $0x8, %r12
jmp 0x187dd
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/compiler/helper/graphs/graph.cpp
// Function: LEAF::HELPER::GRAPH::Graph::path_from(LEAF::HELPER::GRAPH::Node*, std::vector<LEAF::HELPER::GRAPH::Edge*, std::allocator<LEAF::HELPER::GRAPH::Edge*>>*)
void Graph::path_from(Node *a, vector<Edge *> *r)
{

    vector<Edge *>::iterator x = edges->begin();
    for (; x != edges->end(); x++)
    {

        if (0 == strcmp((*x)->nodea->name->c_str(), a->name->c_str()))
        {

            r->push_back((*x));
            path_from((*x)->nodeb, r);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rax
movq (%rax), %r12
cmpq 0x8(%rax), %r12
je 0x188d6
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%r12), %r13
movq (%r13), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq (%r14), %rax
movq (%rax), %rsi
callq 0x53a0
testl %eax, %eax
jne 0x188c9
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x188ab
movq %r13, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x188b6
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1891e
movq (%r12), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1885c
addq $0x8, %r12
movq (%r15), %rax
cmpq 0x8(%rax), %r12
jne 0x1887a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/make_shared.cc
// Function: main
int main(int argc, char const *argv[])
{
	auto num = cplusplus_primer::make_shared<int>(42);
	std::cout << *num << std::endl;

	// basic_string(size_type count, CharT ch, const Allocator& alloc = Allocator());
	auto str = cplusplus_primer::make_shared<std::string>(10, 'c');
	std::cout << *str << std::endl;

	auto foo = cplusplus_primer::make_shared<Foo>(99);
	std::cout << foo->bar << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x18, %edi
callq 0x1070
movq %rax, %rbx
movabsq $0x100000001, %r15      # imm = 0x100000001
movq %r15, 0x8(%rax)
leaq 0x2a15(%rip), %rax      # 0x3c70
movq %rax, (%rbx)
movl $0x2a, 0x10(%rbx)
movq 0x2d6c(%rip), %rdi      # 0x3fd8
movl $0x2a, %esi
callq 0x10d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
leaq -0x34(%rbp), %rcx
movl $0xa, (%rcx)
leaq -0x19(%rbp), %r8
movb $0x63, (%r8)
leaq -0x28(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x30(%rbp), %rsi
leaq -0x1a(%rbp), %rdx
callq 0x14c6
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x2cfb(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movl $0x18, %edi
callq 0x1070
movq %rax, %r14
movq %r15, 0x8(%rax)
leaq 0x2a4c(%rip), %rax      # 0x3d70
movq %rax, (%r14)
movl $0x63, 0x10(%r14)
movq 0x2ca2(%rip), %rdi      # 0x3fd8
movl $0x63, %esi
callq 0x10d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %r14, %rdi
callq 0x13cc
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x1380
callq 0x13cc
movq %rbx, %rdi
callq 0x13cc
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13a6
jmp 0x13b9
movq %rax, %r15
movq %r14, %rdi
callq 0x13cc
jmp 0x13a9
movq %rax, %r15
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x13bc
callq 0x13cc
jmp 0x13bc
movq %rax, %r15
movq %rbx, %rdi
callq 0x13cc
movq %r15, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/threads/benchmark/bench.cpp
// Function: main
int main(){
    bench(bench_lock);
    bench(bench_lock_guard);
    bench(bench_atomic);

    return 0;
}

// Assembly:
pushq %rax
callq 0x2349
callq 0x24f8
callq 0x26cb
callq 0x289e
callq 0x2a71
callq 0x2c44
callq 0x2e17
callq 0x2fea
callq 0x31bd
callq 0x336c
callq 0x353f
callq 0x3712
callq 0x38e5
callq 0x3ab8
callq 0x3c8b
callq 0x3e5e
callq 0x4031
callq 0x41bc
callq 0x4369
callq 0x4516
callq 0x46c3
callq 0x4870
callq 0x4a1d
callq 0x4bca
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/threads/benchmark/bench.cpp
// Function: void bench_atomic<2>()
void bench_atomic(){
    std::mutex mutex;
    unsigned long throughput = 0;

    for(int i = 0; i < REPEAT; ++i){
        std::atomic<int> counter;
        counter.store(0);

        std::vector<std::thread> threads;

        Clock::time_point t0 = Clock::now();

        for(int i = 0; i < Threads; ++i){
            threads.push_back(std::thread([&](){
                for(int i = 0; i < OPERATIONS; ++i){
                    ++counter;
                }
            }));
        }

        for(auto& thread : threads){
            thread.join();
        }

        Clock::time_point t1 = Clock::now();

        milliseconds ms = std::chrono::duration_cast<milliseconds>(t1 - t0);
        throughput += (Threads * OPERATIONS) / ms.count();
    }
    std::cout << "atomic with " << Threads << " threads throughput = " << (throughput / REPEAT) << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq $0x0, 0x10(%rsp)
leaq 0xc(%rsp), %r13
leaq 0x18(%rsp), %r14
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r12
xorl %eax, %eax
movl %eax, 0x8(%rsp)
xorl %eax, %eax
xchgl %eax, 0xc(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x1, %ebp
callq 0x2040
movq %rax, 0x38(%rsp)
movq %r13, 0x40(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5cf2
movq %r12, %rdi
movq %r14, %rsi
callq 0x4e2c
cmpq $0x0, 0x18(%rsp)
jne 0x4364
decl %ebp
je 0x4215
movq 0x20(%rsp), %rbp
movq 0x28(%rsp), %rbx
cmpq %rbx, %rbp
je 0x425d
movq %rbp, %rdi
callq 0x2160
addq $0x8, %rbp
jmp 0x424a
callq 0x2040
subq 0x38(%rsp), %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rcx
addq %rax, %rcx
movl $0x7a120, %eax          # imm = 0x7A120
xorl %edx, %edx
idivq %rcx
addq %rax, 0x10(%rsp)
movq %r12, %rdi
callq 0x4df8
movl 0x8(%rsp), %eax
incl %eax
cmpl $0x5, %eax
jne 0x41e9
movq 0x6d26(%rip), %r14      # 0xafd8
leaq 0x2db4(%rip), %rsi      # 0x706d
movl $0xc, %edx
movq %r14, %rdi
callq 0x2130
movq %r14, %rdi
movl $0x2, %esi
callq 0x2170
movq %rax, %r14
leaq 0x2d4e(%rip), %rsi      # 0x702b
movl $0x16, %edx
movq %rax, %rdi
callq 0x2130
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
movq 0x10(%rsp), %rdx
mulxq %rax, %rsi, %rsi
shrq $0x2, %rsi
movq %r14, %rdi
callq 0x20a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x434f
jmp 0x434f
cmpq $0x0, 0x18(%rsp)
jne 0x4364
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4df8
movq %rbx, %rdi
callq 0x2180
callq 0x2050
// File: /workspace/github_cpp_makefile_star2_O1/frainfreeze[P]tss/./builtins.h
// Function: builtins::tss_help(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int tss_help(std::string name)
{
    std::cout << "Tom's simple shell\n"
              << "These shell commands are defined internally. Type 'help' to see this list.\n"
              << "Type 'help name' to find out more about the function 'name'.\n"
              << "The following are built in: "
              << tss_get()
              << std::endl;
    /// \todo Help for individual commands
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x4909(%rip), %rbx      # 0x6fc0
leaq 0x194b(%rip), %rsi      # 0x4009
movl $0x13, %edx
movq %rbx, %rdi
callq 0x21b0
leaq 0x194b(%rip), %rsi      # 0x401d
movl $0x4b, %edx
movq %rbx, %rdi
callq 0x21b0
leaq 0x1983(%rip), %rsi      # 0x4069
movl $0x3d, %edx
movq %rbx, %rdi
callq 0x21b0
leaq 0x19ad(%rip), %rsi      # 0x40a7
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x21b0
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2797
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2765
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2180
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x278f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/frainfreeze[P]tss/./builtins.h
// Function: builtins::tss_get[abi:cxx11]()
std::string tss_get()
{
    std::string str;
    for(auto elem : funcMap)
        str.append("\n " + elem.first);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x49df(%rip), %r14      # 0x71a8
leaq 0x49c8(%rip), %rax      # 0x7198
cmpq %rax, %r14
je 0x287c
leaq -0x70(%rbp), %r15
leaq -0x90(%rbp), %r12
leaq -0x50(%rbp), %r13
leaq 0x20(%r14), %rsi
movq %r12, %rdi
callq 0x3110
movq %r13, %rdi
leaq 0x18ce(%rip), %rsi      # 0x40cc
movq %r12, %rdx
callq 0x316f
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x20a0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x282f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2180
movq -0x60(%rbp), %rax
testq %rax, %rax
je 0x2845
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x2861
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2110
movq %rax, %r14
leaq 0x4925(%rip), %rax      # 0x7198
cmpq %rax, %r14
jne 0x27e8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x32bf
movq %rax, %r14
jmp 0x28c8
movq %rax, %r14
jmp 0x28bc
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x28bc
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2180
leaq -0x90(%rbp), %rdi
callq 0x3038
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x28e0
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2290