LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rcolomina[P]the_charmed_house/src/logger.cpp
// Function: Logger::instance()
Logger& Logger::instance()
{
    static Cleanup cleanup;

    lock_guard<mutex> guard(sMutex);
    if (pInstance == nullptr)
        pInstance = new Logger();
    return *pInstance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
cmpb $0x0, 0x3ba21(%rip)     # 0x76460
jne 0x3aa78
leaq 0x3ba18(%rip), %rdi     # 0x76460
callq 0x56f0
cmpl $0x0, %eax
je 0x3aa78
leaq 0xc7(%rip), %rdi        # 0x3ab20
leaq 0x3b9f8(%rip), %rsi     # 0x76458
leaq 0x36941(%rip), %rdx     # 0x713a8
callq 0x5340
leaq 0x3b9ed(%rip), %rdi     # 0x76460
callq 0x5240
leaq -0x8(%rbp), %rdi
leaq 0x3b9ad(%rip), %rsi     # 0x76430
callq 0x3aef0
cmpq $0x0, 0x3b998(%rip)     # 0x76428
jne 0x3aae4
movl $0x208, %edi            # imm = 0x208
callq 0x53c0
movq %rax, -0x20(%rbp)
jmp 0x3aaa2
movq -0x20(%rbp), %rdi
callq 0x3ac00
jmp 0x3aaad
movq -0x20(%rbp), %rax
movq %rax, 0x3b970(%rip)     # 0x76428
jmp 0x3aae4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x3ab02
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0x53d0
jmp 0x3ab02
movq 0x3b93d(%rip), %rax     # 0x76428
movq %rax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x3af20
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
leaq -0x8(%rbp), %rdi
callq 0x3af20
movq -0x10(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: rcolomina[P]the_charmed_house/src/manager.cpp
// Function: Manager::get_descripcion_estado_actual[abi:cxx11]()
string Manager::get_descripcion_estado_actual(){
    string descripcion=escena_actual->examine();
    descripcion+="\n";
    if(escena_actual->get_objetos_disponibles()!="")
    {
        descripcion+="Puedes ver : \n";
        descripcion+=escena_actual->get_objetos_disponibles();
    }
    return descripcion;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x11(%rbp)
movq 0x150(%rax), %rsi
callq 0x2dc60
movq -0x70(%rbp), %rdi
leaq 0x12ca9(%rip), %rsi     # 0x5063a
callq 0x5380
jmp 0x3d998
movq -0x78(%rbp), %rax
movq 0x150(%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2c8d0
jmp 0x3d9ae
leaq 0x12c86(%rip), %rsi     # 0x5063b
leaq -0x48(%rbp), %rdi
callq 0x2d830
movb %al, -0x81(%rbp)
jmp 0x3d9c6
leaq -0x48(%rbp), %rdi
callq 0x5748
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x3d9db
jmp 0x3da59
movq -0x70(%rbp), %rdi
leaq 0x1334e(%rip), %rsi     # 0x50d34
callq 0x5380
jmp 0x3d9ed
movq -0x78(%rbp), %rax
movq 0x150(%rax), %rsi
leaq -0x68(%rbp), %rdi
callq 0x2c8d0
jmp 0x3da03
movq -0x70(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5500
jmp 0x3da12
leaq -0x68(%rbp), %rdi
callq 0x5748
jmp 0x3da59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3da79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5748
jmp 0x3da79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5748
jmp 0x3da79
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3da6c
movq -0x70(%rbp), %rdi
callq 0x5748
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x5748
movq -0x20(%rbp), %rdi
callq 0x56c0
nopl (%rax,%rax)
// File: rcolomina[P]the_charmed_house/src/manager.cpp
// Function: Manager::clock()
void Manager::clock(){

    while(continuar_loop)
    {
        int itime = (int) tiempo;
        if( itime % (5*60) == 0 )
        {
            cout<<"\nHan pasado "<<tiempo<<" segundos desde el inicio del juego\n"<<">>>";
        }

        sleep(1); //detiene el hilo durante 1 segundo
        tiempo++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x3dba5
movq -0x18(%rbp), %rax
cvttsd2si 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x12c, %ecx            # imm = 0x12C
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3db80
movq 0x33473(%rip), %rdi     # 0x70fb8
leaq 0x131f7(%rip), %rsi     # 0x50d43
callq 0x53a0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x5720
movq %rax, %rdi
leaq 0x131e4(%rip), %rsi     # 0x50d50
callq 0x53a0
movq %rax, %rdi
leaq 0x130c3(%rip), %rsi     # 0x50c3e
callq 0x53a0
movl $0x1, %edi
callq 0x52c0
movq -0x18(%rbp), %rax
movsd 0x13022(%rip), %xmm0    # 0x50bb8
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x3db14
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rcolomina[P]the_charmed_house/src/objeto.cpp
// Function: Objeto::tirar()
void Objeto::tirar()
{
     cout<<endl<<descripcion_tirar<<endl;
     if(objeto_rel_tirar!=NULL)
     {
	  objeto_rel_tirar->set_value(string("visibility"),true);
     }
     else
     {
	  cout<<"ERROR: Null object"<<endl;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x2fb0d(%rip), %rdi     # 0x70fb8
movq 0x2fade(%rip), %rsi     # 0x70f90
callq 0x5400
movq -0x48(%rbp), %rsi
movq %rax, %rdi
addq $0x178, %rsi            # imm = 0x178
callq 0x5350
movq %rax, %rdi
movq 0x2fabc(%rip), %rsi     # 0x70f90
callq 0x5400
movq -0x48(%rbp), %rax
cmpq $0x0, 0x198(%rax)
je 0x41573
movq -0x48(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x56d0
movq -0x50(%rbp), %rdx
leaq 0xeba7(%rip), %rsi      # 0x500b9
leaq -0x28(%rbp), %rdi
callq 0x299c0
jmp 0x4151d
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x41380
jmp 0x41531
leaq -0x28(%rbp), %rdi
callq 0x5748
leaq -0x29(%rbp), %rdi
callq 0x5420
jmp 0x41595
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x41568
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5748
leaq -0x29(%rbp), %rdi
callq 0x5420
jmp 0x4159b
movq 0x2fa3e(%rip), %rdi     # 0x70fb8
leaq 0xf809(%rip), %rsi      # 0x50d8a
callq 0x53a0
movq %rax, %rdi
movq 0x2fa00(%rip), %rsi     # 0x70f90
callq 0x5400
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: rcolomina[P]the_charmed_house/src/objeto.cpp
// Function: Objeto::set_tirable(Objeto*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Objeto::set_tirable(Objeto *objeto,string descrip_tirable)
{
     if(objeto!=NULL)
     {
	  this->objeto_rel_tirar=objeto;
	  objeto_rel_tirar->set_value(string("visibility"),false);
	  this->descripcion_tirar=descrip_tirable;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4167f
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x198(%rax)
movq 0x198(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x56d0
movq -0x68(%rbp), %rdx
leaq 0xeaac(%rip), %rsi      # 0x500b9
leaq -0x38(%rbp), %rdi
callq 0x299c0
jmp 0x41618
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x41380
jmp 0x41629
leaq -0x38(%rbp), %rdi
callq 0x5748
leaq -0x39(%rbp), %rdi
callq 0x5420
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0x178, %rdi            # imm = 0x178
callq 0x5060
jmp 0x4167f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x41674
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5748
leaq -0x39(%rbp), %rdi
callq 0x5420
jmp 0x41685
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x56c0
nop
// File: rcolomina[P]the_charmed_house/src/objeto.cpp
// Function: bool Objeto::get_value<bool>(char const*)
bool Objeto::get_value<bool>(const char* pro)
{			 
    pBool pb=map_pBools[string(pro)];
    bool value=false; // TODO: Return false value by default 
    if(pb!=NULL)
    {
        value=pb->Value();
    }
#ifdef _DEBUG
    cout<<"get_value:"<<pro<<" valueProp:"<<value<<endl;
    cout<<"get_value:"<<pro<<" valueBool:"<<mapBool[string(pro)]<<endl;
#endif			 
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0xc8, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x56d0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x299c0
jmp 0x416d9
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x41980
movq %rax, -0x70(%rbp)
jmp 0x416ec
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5748
leaq -0x39(%rbp), %rdi
callq 0x5420
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x4d(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4175a
movq -0x18(%rbp), %rdi
callq 0x41d70
andb $0x1, %al
movb %al, -0x4d(%rbp)
jmp 0x4175a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4174f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5748
leaq -0x39(%rbp), %rdi
callq 0x5420
jmp 0x41768
movb -0x4d(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: rcolomina[P]the_charmed_house/src/objeto.cpp
// Function: int Objeto::get_value<int>(char const*)
int Objeto::get_value<int>(const char* pro)
{			 
    pInt pI=map_pInts[string(pro)];
    int value=0; 
    if(pI!=NULL)
    {
        value=pI->Value();
    }
#ifdef _DEBUG
    cout<<"get_value:"<<pro<<" valueProp:"<<value<<endl;
    cout<<"get_value:"<<pro<<" valueInts:"<<map_pInts[string(pro)]<<endl;
#endif			 
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x128, %rax            # imm = 0x128
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x56d0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x299c0
jmp 0x417c9
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x41d90
movq %rax, -0x70(%rbp)
jmp 0x417dc
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5748
leaq -0x39(%rbp), %rdi
callq 0x5420
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x50(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4184b
movq -0x18(%rbp), %rdi
callq 0x41e70
movl %eax, -0x50(%rbp)
jmp 0x4184b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x41840
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5748
leaq -0x39(%rbp), %rdi
callq 0x5420
jmp 0x41857
movl -0x50(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x56c0
// File: rcolomina[P]the_charmed_house/src/objeto.cpp
// Function: Objeto::activate_event()
IEvent* Objeto::activate_event()
{
    if(!eventsToFire.empty())
    {
        IEvent *event=eventsToFire.front();
        eventsToFire.pop();
        return event;					
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x1c8, %rdi            # imm = 0x1C8
callq 0x332b0
testb $0x1, %al
jne 0x418e5
movq -0x20(%rbp), %rdi
addq $0x1c8, %rdi            # imm = 0x1C8
callq 0x332d0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x1c8, %rdi            # imm = 0x1C8
callq 0x332f0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x418ed
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rcolomina[P]the_charmed_house/src/operaciones.cpp
// Function: Ayuda::execute()
void Ayuda::execute(){

    cout<<"Comandos disponibles:"<<endl;
				 
    for(vector<string>::iterator it=v_comandos.begin();
        it!=v_comandos.end();
        it++)
    {
        cout<<*it<<" ";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x2cb2d(%rip), %rdi     # 0x70fb8
leaq 0xc910(%rip), %rsi      # 0x50da2
callq 0x53a0
movq %rax, %rdi
movq 0x2caef(%rip), %rsi     # 0x70f90
callq 0x5400
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x2a3d0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x2a250
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x38f60
testb $0x1, %al
jne 0x444db
jmp 0x44513
leaq -0x10(%rbp), %rdi
callq 0x369d0
movq %rax, %rsi
movq 0x2caca(%rip), %rdi     # 0x70fb8
callq 0x5350
movq %rax, %rdi
leaq 0xd133(%rip), %rsi      # 0x51630
callq 0x53a0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x36af0
movq %rax, -0x20(%rbp)
jmp 0x444b7
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_22_main.cc
// Function: runQueries(std::basic_ifstream<char, std::char_traits<char>>&)
void runQueries(ifstream& infile)
{
	// infile is an ifstream that is the file we want to query
	TextQuery tq(infile);  // store the file and build the query map
	// iterate with the user: prompt for a word to find and print results
	while (true) {
		cout << "enter word to look for, or q to quit: ";
		string s;
		// stop if we hit end-of-file on the input or if a 'q' is entered
		if (!(cin >> s) || s == "q")
			break;
		// run the query and print the results
		print(cout, tq.query(s)) << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2da0
jmp 0x24ae
movq 0xcb13(%rip), %rdi      # 0xefc8
leaq 0x6b48(%rip), %rsi      # 0x9004
callq 0x21c0
jmp 0x24c3
leaq -0x78(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x2260
movq -0xd0(%rbp), %rsi
movq 0xcaf7(%rip), %rdi      # 0xefd8
callq 0x2250
movq %rax, -0xc8(%rbp)
jmp 0x24ef
movq -0xc8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x20d0
movb %al, -0xd1(%rbp)
jmp 0x250d
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x253d
jmp 0x2519
leaq 0x6b0b(%rip), %rsi      # 0x902b
leaq -0x78(%rbp), %rdi
callq 0x2750
movb %al, -0xd2(%rbp)
jmp 0x2531
movb -0xd2(%rbp), %al
testb $0x1, %al
jne 0x253d
jmp 0x2568
movl $0x3, -0x7c(%rbp)
jmp 0x25c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2610
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x25f3
leaq -0xc0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x31e0
jmp 0x257e
movq 0xca43(%rip), %rdi      # 0xefc8
leaq -0xc0(%rbp), %rsi
callq 0x3660
movq %rax, -0xe0(%rbp)
jmp 0x259a
movq -0xe0(%rbp), %rdi
movq 0xca08(%rip), %rsi      # 0xefb0
callq 0x2200
jmp 0x25af
leaq -0xc0(%rbp), %rdi
callq 0x2780
movl $0x0, -0x7c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2120
movl -0x7c(%rbp), %eax
testl %eax, %eax
je 0x25d6
jmp 0x25d4
jmp 0x25fe
jmp 0x24ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x2780
leaq -0x78(%rbp), %rdi
callq 0x2120
jmp 0x2610
leaq -0x48(%rbp), %rdi
callq 0x27c0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x27c0
movq -0x50(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_22_main.cc
// Function: main
int main(int argc, char const *argv[])
{
	// open the file from which user will query words
	ifstream infile;
	// open returns void, so we use the comma operator XREF(commaOp)
	// to check the state of infile after the open
	if (argc < 2 || !(infile.open(argv[1]), infile)) {
		cerr << "No input file!" << endl;
		return EXIT_FAILURE;
	}
	runQueries(infile);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x2210
cmpl $0x2, -0x8(%rbp)
jl 0x26a2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x2140
jmp 0x2676
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x20d0
movb %al, -0x229(%rbp)
jmp 0x2696
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x26a2
jmp 0x2706
movq 0xc947(%rip), %rdi      # 0xeff0
leaq 0x697d(%rip), %rsi      # 0x902d
callq 0x21c0
movq %rax, -0x238(%rbp)
jmp 0x26be
movq -0x238(%rbp), %rdi
movq 0xc8e4(%rip), %rsi      # 0xefb0
callq 0x2200
jmp 0x26d3
movl $0x1, -0x4(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x2725
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x2070
jmp 0x273d
leaq -0x218(%rbp), %rdi
callq 0x2490
jmp 0x2714
movl $0x0, -0x4(%rbp)
movl $0x1, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x2070
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/TextQuery.cc
// Function: TextQuery::display_map()
void TextQuery::display_map()
{
	// auto iter = wm.cbegin();
	// auto iter_end = wm.cend();
	for (auto iter = wm.cbegin(); iter != wm.cend(); ++iter) {
		cout << "word: " << iter->first << " {";
		// fetch location vector as a cosnt reference to avoid coping it
		auto text_locs = iter->second;
		auto loc_iter = text_locs->cbegin();
		auto loc_iter_end = text_locs->cend();
		// print all line number for this word
		while (loc_iter != loc_iter_end) {
			cout << *loc_iter;

			if (++loc_iter != loc_iter_end)
				cout << ", ";
		}
		cout << "}\n";
	}

	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x10, %rdi
callq 0x3d80
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0x3de0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3db0
testb $0x1, %al
jne 0x3518
jmp 0x363a
movq 0xbaa9(%rip), %rdi      # 0xefc8
leaq 0x5b16(%rip), %rsi      # 0x903c
callq 0x21c0
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3d60
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x21a0
movq %rax, %rdi
leaq 0x5af5(%rip), %rsi      # 0x9043
callq 0x21c0
leaq -0x10(%rbp), %rdi
callq 0x3d60
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3ca0
leaq -0x28(%rbp), %rdi
callq 0x3ab0
movq %rax, %rdi
callq 0x3e10
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3ab0
movq %rax, %rdi
callq 0x3e40
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3e70
testb $0x1, %al
jne 0x35a9
jmp 0x360e
leaq -0x30(%rbp), %rdi
callq 0x3ea0
movq (%rax), %rsi
movq 0xba0c(%rip), %rdi      # 0xefc8
callq 0x2060
jmp 0x35c3
leaq -0x30(%rbp), %rdi
callq 0x3ec0
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x3e70
testb $0x1, %al
jne 0x35de
jmp 0x360c
movq 0xb9e3(%rip), %rdi      # 0xefc8
leaq 0x5a5a(%rip), %rsi      # 0x9046
callq 0x21c0
jmp 0x35f3
jmp 0x360c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2810
jmp 0x3653
jmp 0x3596
movq 0xb9b3(%rip), %rdi      # 0xefc8
leaq 0x5a2d(%rip), %rsi      # 0x9049
callq 0x21c0
jmp 0x3623
leaq -0x28(%rbp), %rdi
callq 0x2810
leaq -0x10(%rbp), %rdi
callq 0x3ef0
jmp 0x34f1
movq 0xb987(%rip), %rdi      # 0xefc8
movq 0xb968(%rip), %rsi      # 0xefb0
callq 0x2200
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/TextQuery.cc
// Function: print(std::ostream&, QueryResult const&)
ostream& print(ostream& os, const QueryResult& qr)
{
	os << qr.sought << " occurs " << qr.lines->size() << " "
	   << "time(s)" << endl;

	// print each line in chich the word appeared
	for (auto num : *qr.lines) {
		os << "\t(line " << num + 1 << ") "
		   << *(qr.file->begin() + num) << endl;
	}

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21a0
movq %rax, %rdi
leaq 0x59c5(%rip), %rsi      # 0x904c
callq 0x21c0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3ab0
movq %rax, %rdi
callq 0x3f20
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2060
movq %rax, %rdi
leaq 0x59ab(%rip), %rsi      # 0x9066
callq 0x21c0
movq %rax, %rdi
leaq 0x598b(%rip), %rsi      # 0x9055
callq 0x21c0
movq %rax, %rdi
movq 0xb8d7(%rip), %rsi      # 0xefb0
callq 0x2200
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3f70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3fa0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3e70
testb $0x1, %al
jne 0x371f
jmp 0x37be
leaq -0x20(%rbp), %rdi
callq 0x3ea0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5923(%rip), %rsi      # 0x905d
callq 0x21c0
movq %rax, %rdi
movq -0x30(%rbp), %rsi
addq $0x1, %rsi
callq 0x2060
movq %rax, %rdi
leaq 0x590c(%rip), %rsi      # 0x9065
callq 0x21c0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x3870
movq %rax, %rdi
callq 0x3fd0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x4000
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4040
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x21a0
movq %rax, %rdi
movq 0xb805(%rip), %rsi      # 0xefb0
callq 0x2200
leaq -0x20(%rbp), %rdi
callq 0x3ec0
jmp 0x3709
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Cicko[P]Ram-Machine/Program.cpp
// Function: Program::readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Program::readFile (string fileName){
  ifstream file;
  string fileData = "";
  fileName_ = fileName;
  file.open (fileName.c_str());
  if (file.is_open()) {
    while (!file.eof()) {
      string temp;
      getline (file,temp);
      fileData += temp + "\n";
    }
    file.close();
  }
  else {
    cerr << "El fichero no existe" << endl;
  }
  return fileData;
}

// Assembly:
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rdx, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x2b0(%rsp)
movq %rsi, 0x2a8(%rsp)
movq %rdx, 0x2a0(%rsp)
movq 0x2a8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x64f0
movb $0x0, 0x97(%rsp)
leaq 0x96(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x67c0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
leaq 0x32838(%rip), %rsi     # 0x3a1ce
callq 0x6610
jmp 0x799d
leaq 0x96(%rsp), %rdi
callq 0x64a0
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x30, %rdi
callq 0x6060
jmp 0x79bf
movq 0x18(%rsp), %rdi
callq 0x6190
movq %rax, %rsi
leaq 0x98(%rsp), %rdi
movl $0x8, %edx
callq 0x62d0
jmp 0x79e0
leaq 0x98(%rsp), %rdi
callq 0x66d0
movb %al, 0x17(%rsp)
jmp 0x79f3
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x7a00
jmp 0x7b25
jmp 0x7a02
movq 0x98(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x98(%rsp,%rax), %rdi
callq 0x67f0
movb %al, 0x16(%rsp)
jmp 0x7a21
movb 0x16(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7a30
jmp 0x7b14
leaq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6620
movq 0x8(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x60c0
jmp 0x7a53
leaq 0x32773(%rip), %rdx     # 0x3a1cd
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x9ba0
jmp 0x7a6b
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x65a0
jmp 0x7a7c
leaq 0x40(%rsp), %rdi
callq 0x62a0
leaq 0x60(%rsp), %rdi
callq 0x62a0
jmp 0x7a02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x96(%rsp), %rdi
callq 0x64a0
jmp 0x7b92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x7b88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x7b08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x62a0
leaq 0x60(%rsp), %rdi
callq 0x62a0
jmp 0x7b88
leaq 0x98(%rsp), %rdi
callq 0x60d0
jmp 0x7b23
jmp 0x7b52
movq 0x484bc(%rip), %rdi     # 0x4ffe8
leaq 0x32879(%rip), %rsi     # 0x3a3ac
callq 0x6430
movq %rax, (%rsp)
jmp 0x7b3e
movq (%rsp), %rdi
movq 0x48427(%rip), %rsi     # 0x4ff70
callq 0x6480
jmp 0x7b50
jmp 0x7b52
movb $0x1, 0x97(%rsp)
testb $0x1, 0x97(%rsp)
jne 0x7b6e
movq 0x30(%rsp), %rdi
callq 0x62a0
leaq 0x98(%rsp), %rdi
callq 0x6100
movq 0x20(%rsp), %rax
addq $0x2b8, %rsp            # imm = 0x2B8
retq
movq 0x30(%rsp), %rdi
callq 0x62a0
leaq 0x98(%rsp), %rdi
callq 0x6100
movq 0x88(%rsp), %rdi
callq 0x67b0
nopl (%rax)
// File: Cicko[P]Ram-Machine/Program.cpp
// Function: Program::existsTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Program::existsTag(string tag)
{
  for(int i = 0; i < tags_.size(); i++) {
    if(tags_[i]->getId() == tag) {
      return true;
    }
  }
  return false;
}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x4c(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
callq 0xa3d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x978a
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movslq 0x4c(%rsp), %rsi
callq 0xa490
movq (%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0xa4b0
movq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xa3f0
movb %al, 0xf(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x62a0
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x9771
jmp 0x9778
movb $0x1, 0x67(%rsp)
jmp 0x978f
jmp 0x977a
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x9705
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: Cicko[P]Ram-Machine/Program.cpp
// Function: Program::show()
void Program::show() {
  cout << "Tags: " << endl;
  for(int i = 0; i < tags_.size(); i++) {
    tags_[i]->show();
  }
  cout << "===============================" << endl;

  cout << "Instructions: " << endl;
  for(int i = 0; i < instructions_.size(); i++) {
    instructions_[i]->show();
  }
  cout << "===============================" << endl << endl;

  cout << "Pulse Enter para volver al menu..." << endl;
  cin.get();
  cin.get();
  system("clear");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x467de(%rip), %rdi     # 0x4ff98
leaq 0x30c8c(%rip), %rsi     # 0x3a44d
callq 0x6430
movq %rax, %rdi
movq 0x467a0(%rip), %rsi     # 0x4ff70
callq 0x6480
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
callq 0xa3d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x982a
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xa490
movq (%rax), %rdi
callq 0xa4e0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x97dd
movq 0x46767(%rip), %rdi     # 0x4ff98
leaq 0x30c1c(%rip), %rsi     # 0x3a454
callq 0x6430
movq %rax, %rdi
movq 0x46729(%rip), %rsi     # 0x4ff70
callq 0x6480
movq 0x46745(%rip), %rdi     # 0x4ff98
leaq 0x30c1a(%rip), %rsi     # 0x3a474
callq 0x6430
movq %rax, %rdi
movq 0x46707(%rip), %rsi     # 0x4ff70
callq 0x6480
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0xa560
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x98b9
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0xa380
movq (%rax), %rdi
callq 0xa580
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x9876
movq 0x466d8(%rip), %rdi     # 0x4ff98
leaq 0x30b8d(%rip), %rsi     # 0x3a454
callq 0x6430
movq %rax, %rdi
movq 0x4669a(%rip), %rsi     # 0x4ff70
callq 0x6480
movq %rax, %rdi
movq 0x4668b(%rip), %rsi     # 0x4ff70
callq 0x6480
movq 0x466a7(%rip), %rdi     # 0x4ff98
leaq 0x30b8b(%rip), %rsi     # 0x3a483
callq 0x6430
movq %rax, %rdi
movq 0x46669(%rip), %rsi     # 0x4ff70
callq 0x6480
movq 0x466bd(%rip), %rdi     # 0x4ffd0
callq 0x6540
movq 0x466b1(%rip), %rdi     # 0x4ffd0
callq 0x6540
leaq 0x307f2(%rip), %rdi     # 0x3a11d
callq 0x63a0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Cicko[P]Ram-Machine/Program.cpp
// Function: Program::getLineByTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Program::getLineByTag(string tag) {
  for (int i = 0; i < tags_.size(); i++)
    if (tags_[i]->getId() == tag)
      return tags_[i]->getLine();
  return -1;
}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x4c(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
callq 0xa3d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x9a04
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movslq 0x4c(%rsp), %rsi
callq 0xa490
movq (%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0xa4b0
movq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xa3f0
movb %al, 0xf(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x62a0
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x99d1
jmp 0x99f2
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movslq 0x4c(%rsp), %rsi
callq 0xa490
movq (%rax), %rdi
callq 0xa660
movl %eax, 0x64(%rsp)
jmp 0x9a0c
jmp 0x99f4
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x9965
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Cicko[P]Ram-Machine/./Instruction.h
// Function: Instruction::Instruction()
Instruction () {
    line_ = -1;
    tag_ = "";
    op_ = "";
    type_ = '\0';
    operand_ = "";
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
movq %rdi, 0x18(%rsp)
callq 0x6620
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, (%rsp)
callq 0x6620
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
movq %rdi, 0x8(%rsp)
callq 0x6620
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
leaq 0x30401(%rip), %rsi     # 0x3a1ce
callq 0x6600
jmp 0x9dd4
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
leaq 0x303ea(%rip), %rsi     # 0x3a1ce
callq 0x6600
jmp 0x9deb
movq 0x10(%rsp), %rdi
movb $0x0, 0x48(%rdi)
addq $0x50, %rdi
leaq 0x303cf(%rip), %rsi     # 0x3a1ce
callq 0x6600
jmp 0x9e06
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x62a0
movq (%rsp), %rdi
callq 0x62a0
movq 0x18(%rsp), %rdi
callq 0x62a0
movq 0x28(%rsp), %rdi
callq 0x67b0
// File: Cicko[P]Ram-Machine/RamMachine.cpp
// Function: RamMachine::RamMachine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
RamMachine::RamMachine(string in, string out, string program, int size)
{
  pc_ = 0;
  inTape_ = new ITape(in);
  outTape_ = new OTape(out);
  program_ = new Program(program);
  memory_ = new Memory(size);
  error_ = false;
}

// Assembly:
subq $0xe8, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movl %r8d, 0xc4(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x20(%rax)
movl $0x40, %edi
callq 0x6440
movq 0x30(%rsp), %rsi
movq %rax, 0x38(%rsp)
movb $0x1, 0x93(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x61b0
jmp 0x34b2d
movq 0x38(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x375f0
jmp 0x34b41
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
movb $0x0, 0x93(%rsp)
movq %rcx, (%rax)
leaq 0xa0(%rsp), %rdi
callq 0x62a0
movl $0x40, %edi
callq 0x6440
movq 0x18(%rsp), %rsi
movq %rax, 0x10(%rsp)
movb $0x1, 0x6f(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x61b0
jmp 0x34b88
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x38280
jmp 0x34b99
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, 0x6f(%rsp)
movq %rcx, 0x8(%rax)
leaq 0x70(%rsp), %rdi
callq 0x62a0
movl $0x50, %edi
callq 0x6440
movq 0x20(%rsp), %rsi
movq %rax, 0x8(%rsp)
movb $0x1, 0x47(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x61b0
jmp 0x34bdb
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x7690
jmp 0x34bec
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, 0x47(%rsp)
movq %rcx, 0x18(%rax)
leaq 0x48(%rsp), %rdi
callq 0x62a0
movl $0x18, %edi
callq 0x6440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movl 0xc4(%rsp), %esi
callq 0x38890
jmp 0x34c2b
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
movb $0x0, 0x24(%rax)
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x34c7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x62a0
testb $0x1, 0x93(%rsp)
jne 0x34c87
jmp 0x34c91
movq 0x38(%rsp), %rdi
callq 0x6410
jmp 0x34d45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x34cca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x62a0
testb $0x1, 0x6f(%rsp)
jne 0x34cd3
jmp 0x34cdd
movq 0x10(%rsp), %rdi
callq 0x6410
jmp 0x34d45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x34d13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x62a0
testb $0x1, 0x47(%rsp)
jne 0x34d1c
jmp 0x34d26
movq 0x8(%rsp), %rdi
callq 0x6410
jmp 0x34d45
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x6410
movq 0x98(%rsp), %rdi
callq 0x67b0
nopw %cs:(%rax,%rax)
// File: Cicko[P]Ram-Machine/RamMachine.cpp
// Function: RamMachine::~RamMachine()
RamMachine::~RamMachine() {
  delete memory_;
  delete inTape_;
  delete outTape_;
  delete program_;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x34d96
movq 0x28(%rsp), %rdi
callq 0x388f0
movq 0x28(%rsp), %rdi
callq 0x6410
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x34dbd
movq 0x18(%rsp), %rdi
callq 0x377d0
movq 0x18(%rsp), %rdi
callq 0x6410
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x34de5
movq 0x10(%rsp), %rdi
callq 0x382e0
movq 0x10(%rsp), %rdi
callq 0x6410
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x34e0d
movq 0x8(%rsp), %rdi
callq 0x7850
movq 0x8(%rsp), %rdi
callq 0x6410
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Cicko[P]Ram-Machine/RamMachine.cpp
// Function: RamMachine::jumpManager(Instruction*)
void RamMachine::jumpManager (Instruction* actual) {
  pc_ = program_->getLineByTag (actual->getOperand());
  if (pc_ == -1) {
    cout << "el Tag " << actual->getOperand () << " no se encuentra en el programa.\nSaliendo al menu..." << endl;
    error_ = true;
  }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x373f0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x9940
movl %eax, 0x44(%rsp)
jmp 0x36da9
movq 0x28(%rsp), %rax
movl 0x44(%rsp), %ecx
movl %ecx, 0x20(%rax)
leaq 0x78(%rsp), %rdi
callq 0x62a0
movq 0x28(%rsp), %rax
cmpl $-0x1, 0x20(%rax)
jne 0x36e87
movq 0x191c3(%rip), %rdi     # 0x4ff98
leaq 0x47fa(%rip), %rsi      # 0x3b5d6
callq 0x6430
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x373f0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x63e0
movq %rax, 0x20(%rsp)
jmp 0x36e13
movq 0x20(%rsp), %rdi
leaq 0x47bf(%rip), %rsi      # 0x3b5de
callq 0x6430
movq %rax, 0x8(%rsp)
jmp 0x36e2b
movq 0x8(%rsp), %rdi
movq 0x19139(%rip), %rsi     # 0x4ff70
callq 0x6480
jmp 0x36e3e
leaq 0x48(%rsp), %rdi
callq 0x62a0
movq 0x28(%rsp), %rax
movb $0x1, 0x24(%rax)
jmp 0x36e87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x62a0
jmp 0x36e8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x62a0
jmp 0x36e8f
addq $0xa8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x67b0
nopl (%rax)
// File: Cicko[P]Ram-Machine/RamMachine.cpp
// Function: RamMachine::showActualState(Instruction*)
void RamMachine::showActualState (Instruction* actual) {
  cout << "Input tape:" << endl;
  inTape_->show();
  actual->show();
  memory_->show();
  cout << "Contenido de la cinta de salida: " ;
  outTape_->show();
  cout << endl << endl << "Pulse Enter para continuar..." << endl;
  cin.get();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x190da(%rip), %rdi     # 0x4ff98
leaq 0x46c5(%rip), %rsi      # 0x3b58a
callq 0x6430
movq %rax, %rdi
movq 0x1909c(%rip), %rsi     # 0x4ff70
callq 0x6480
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x385e0
movq 0x8(%rsp), %rdi
callq 0xa580
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x389d0
movq 0x19095(%rip), %rdi     # 0x4ff98
leaq 0x468c(%rip), %rsi      # 0x3b596
callq 0x6430
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x385e0
movq 0x19075(%rip), %rdi     # 0x4ff98
movq 0x19046(%rip), %rsi     # 0x4ff70
callq 0x6480
movq %rax, %rdi
movq 0x19037(%rip), %rsi     # 0x4ff70
callq 0x6480
movq %rax, %rdi
leaq 0x4670(%rip), %rsi      # 0x3b5b8
callq 0x6430
movq %rax, %rdi
movq 0x19019(%rip), %rsi     # 0x4ff70
callq 0x6480
movq 0x1906d(%rip), %rdi     # 0x4ffd0
callq 0x6540
addq $0x18, %rsp
retq
nopl (%rax)
// File: Cicko[P]Ram-Machine/RamMachine.cpp
// Function: RamMachine::saveToOutputTape()
void RamMachine::saveToOutputTape () {
  outTape_->saveToFile();
  cout << "Pulse Enter para volver al menu..." << endl;
  cin.get();
  cin.get();
  system("clear");
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x38360
movq 0x1900f(%rip), %rdi     # 0x4ff98
leaq 0x34f3(%rip), %rsi      # 0x3a483
callq 0x6430
movq %rax, %rdi
movq 0x18fd1(%rip), %rsi     # 0x4ff70
callq 0x6480
movq 0x19025(%rip), %rdi     # 0x4ffd0
callq 0x6540
movq 0x19019(%rip), %rdi     # 0x4ffd0
callq 0x6540
leaq 0x315a(%rip), %rdi      # 0x3a11d
callq 0x63a0
popq %rax
retq
nopw (%rax,%rax)
// File: Cicko[P]Ram-Machine/ITape.cpp
// Function: ITape::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ITape::load(string fileName) {
  inx_ = 0;
  fstream file;
  int num;
  fileName_ = fileName;
  file.open(fileName.c_str(), ios::in );

  if(file.is_open()) {
      nodes_.clear();
    while(file >> num){
      nodes_.push_back(num);
    }
    file.close();
  }
  else{
      cerr << "El fichero no existe" << endl;
  }
}

// Assembly:
subq $0x268, %rsp            # imm = 0x268
movq %rsi, 0x28(%rsp)
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq 0x260(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x18(%rax)
leaq 0x48(%rsp), %rdi
callq 0x6520
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x20, %rdi
callq 0x6060
jmp 0x376cf
movq 0x28(%rsp), %rdi
callq 0x6190
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
movl $0x8, %edx
callq 0x6400
jmp 0x376ed
leaq 0x48(%rsp), %rdi
callq 0x6770
movb %al, 0x1f(%rsp)
jmp 0x376fd
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x37707
jmp 0x37786
movq 0x20(%rsp), %rdi
callq 0x37930
leaq 0x48(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0x6290
movq %rax, 0x10(%rsp)
jmp 0x37727
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6570
movb %al, 0xf(%rsp)
jmp 0x37741
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3774b
jmp 0x37778
movq 0x20(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0x37950
jmp 0x3775c
jmp 0x37711
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x60e0
jmp 0x377c5
leaq 0x48(%rsp), %rdi
callq 0x6090
jmp 0x37784
jmp 0x377b3
movq 0x1885b(%rip), %rdi     # 0x4ffe8
leaq 0x2c18(%rip), %rsi      # 0x3a3ac
callq 0x6430
movq %rax, (%rsp)
jmp 0x3779f
movq (%rsp), %rdi
movq 0x187c6(%rip), %rsi     # 0x4ff70
callq 0x6480
jmp 0x377b1
jmp 0x377b3
leaq 0x48(%rsp), %rdi
callq 0x60e0
addq $0x268, %rsp            # imm = 0x268
retq
movq 0x38(%rsp), %rdi
callq 0x67b0
nop
// File: Cicko[P]Ram-Machine/OTape.cpp
// Function: OTape::saveToFile()
void OTape::saveToFile() {
  ofstream outFile;
  outFile.open(fileName_.c_str());
  char option;
  cout << "¿Desea ver el contenido que se va a volcar en la cinta de salida? (s/n): " ;
  cin >> option;
  if (option == 's')
     show();

  for(int i = 0; i < nodes_.size(); i++) {
    outFile << nodes_[i] << " ";
  }
  outFile.close();
}

// Assembly:
subq $0x248, %rsp            # imm = 0x248
movq %rdi, 0x240(%rsp)
movq 0x240(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x6740
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x6190
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x6080
jmp 0x383ad
movq 0x17be4(%rip), %rdi     # 0x4ff98
leaq 0x325d(%rip), %rsi      # 0x3b618
callq 0x6430
jmp 0x383c2
movq 0x17c07(%rip), %rdi     # 0x4ffd0
leaq 0x33(%rsp), %rsi
callq 0x65e0
jmp 0x383d5
movsbl 0x33(%rsp), %eax
cmpl $0x73, %eax
jne 0x3840a
movq 0x18(%rsp), %rdi
callq 0x385e0
jmp 0x383eb
jmp 0x3840a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x6690
jmp 0x38495
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x379c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x38477
movq 0x18(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x379e0
movl (%rax), %esi
leaq 0x40(%rsp), %rdi
callq 0x6780
movq %rax, 0x8(%rsp)
jmp 0x38455
movq 0x8(%rsp), %rdi
leaq 0x321a(%rip), %rsi      # 0x3b67b
callq 0x6430
jmp 0x38468
jmp 0x3846a
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x38412
leaq 0x40(%rsp), %rdi
callq 0x6650
jmp 0x38483
leaq 0x40(%rsp), %rdi
callq 0x6690
addq $0x248, %rsp            # imm = 0x248
retq
movq 0x38(%rsp), %rdi
callq 0x67b0
nop
// File: Cicko[P]Ram-Machine/Tape.cpp
// Function: Tape::show()
void Tape::show()
{
  cout << "[" ;
  for (int i = 0; i < nodes_.size(); i++)
  {
    cout << " " << nodes_[i];
    if (i < nodes_.size()-1) {
      cout << ",";
    }
  }
  cout << "]" << endl;
  cout << endl;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x1799e(%rip), %rdi     # 0x4ff98
leaq 0x1ebc(%rip), %rsi      # 0x3a4bd
callq 0x6430
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x379c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x386ac
movq 0x17962(%rip), %rdi     # 0x4ff98
leaq 0x303e(%rip), %rsi      # 0x3b67b
callq 0x6430
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
movslq 0x2c(%rsp), %rsi
callq 0x379e0
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x6780
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x379c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3869a
movq 0x1790a(%rip), %rdi     # 0x4ff98
leaq 0x2fce(%rip), %rsi      # 0x3b663
callq 0x6430
jmp 0x3869c
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3860e
movq 0x178e5(%rip), %rdi     # 0x4ff98
leaq 0x1d4c(%rip), %rsi      # 0x3a406
callq 0x6430
movq %rax, %rdi
movq 0x178a7(%rip), %rsi     # 0x4ff70
callq 0x6480
movq 0x178c3(%rip), %rdi     # 0x4ff98
movq 0x17894(%rip), %rsi     # 0x4ff70
callq 0x6480
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/rossa.h
// Function: printc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, TextColor const&)
inline void printc(const std::string &s, const TextColor &color)
{
#ifndef _WIN32
	std::cout << colorASCII(color) << s << colorASCII(0);
#else
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleTextAttribute(hConsole, color);
	std::cout << s;
	SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x24d00
movq -0xe8(%rbp), %rdx
leaq 0x12ba0c(%rip), %rsi    # 0x150233
leaq -0x50(%rbp), %rdi
callq 0x24cb0
jmp 0x24832
leaq 0x12bb1f(%rip), %rdx    # 0x150358
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x24c60
jmp 0x24848
movq 0x1c0751(%rip), %rdi    # 0x1e4fa0
leaq -0x30(%rbp), %rsi
callq 0x114e0
movq %rax, -0xf0(%rbp)
jmp 0x24861
movq -0xf0(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x114e0
movq %rax, -0xf8(%rbp)
jmp 0x2487a
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
callq 0x24d00
jmp 0x2488a
leaq 0x12b9a2(%rip), %rsi    # 0x150233
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
callq 0x24cb0
jmp 0x248a6
leaq 0x12baab(%rip), %rdx    # 0x150358
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x24c60
jmp 0x248c2
movq -0xf8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x114e0
jmp 0x248d7
leaq -0xa0(%rbp), %rdi
callq 0x11360
leaq -0xc0(%rbp), %rdi
callq 0x11360
leaq -0xe0(%rbp), %rdi
callq 0x11360
leaq -0x30(%rbp), %rdi
callq 0x11360
leaq -0x50(%rbp), %rdi
callq 0x11360
leaq -0x70(%rbp), %rdi
callq 0x11360
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x249a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x2499e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x24995
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x24989
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x2497d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x11360
leaq -0xc0(%rbp), %rdi
callq 0x11360
leaq -0xe0(%rbp), %rdi
callq 0x11360
leaq -0x30(%rbp), %rdi
callq 0x11360
leaq -0x50(%rbp), %rdi
callq 0x11360
leaq -0x70(%rbp), %rdi
callq 0x11360
movq -0x78(%rbp), %rdi
callq 0x119c0
nopl (%rax)
// File: Nallantli[P]Rossa/main/rossa/parser/parser.cpp
// Function: parser_t::compileCode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::filesystem::__cxx11::path const&)
const ptr_node_t parser_t::compileCode(const std::string &code, const std::filesystem::path &currentFile)
{
	auto tokens = lexString(code, currentFile);
	node_parser_t testnp(tokens, currentFile);
	auto n = testnp.parse(&this->scopes, &this->consts);
	// fold twice (temporary) to refold constants
	return n->fold(this->consts)->fold(this->consts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x35510
movq -0x148(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x110(%rbp), %rdi
callq 0x38f50
jmp 0x2b378
movq -0x150(%rbp), %rcx
movq %rcx, %rdx
addq $0x18, %rdx
leaq -0x130(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x56dd0
jmp 0x2b39b
leaq -0x130(%rbp), %rdi
callq 0x2d030
movq -0x150(%rbp), %rdx
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x140(%rbp), %rdi
callq *%rax
jmp 0x2b3c3
leaq -0x140(%rbp), %rdi
callq 0x2d030
movq -0x160(%rbp), %rdi
movq -0x150(%rbp), %rdx
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x2b3eb
leaq -0x140(%rbp), %rdi
callq 0x24b20
leaq -0x130(%rbp), %rdi
callq 0x24b20
leaq -0x110(%rbp), %rdi
callq 0x2d050
leaq -0x38(%rbp), %rdi
callq 0x2d090
movq -0x158(%rbp), %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x2b49a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x2b48e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x2b482
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x24b20
leaq -0x130(%rbp), %rdi
callq 0x24b20
leaq -0x110(%rbp), %rdi
callq 0x2d050
leaq -0x38(%rbp), %rdi
callq 0x2d090
movq -0x118(%rbp), %rdi
callq 0x119c0
nop