LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: NGageMegaman[P]NEScutre/src/mem_ppu.cpp
// Function: Mem_ppu::load_rom(char*)
void Mem_ppu::load_rom(char *name) {
    /*This rom loads .nes roms in iNES file format
    The iNES file format follows the following sections:
    
    1. Header (16 bytes)
    2. Trainer, if present(0 or 512 bytes)
    3. PRG ROM data (16384 * x bytes)
    4. CHR ROM data, if present (8192 * y bytes)
    5. PlayChoice INST-ROM, if present (0 or 8192 bytes)
    6. PlayChoice PROM, if present (16 bytes Data, 16 CounterOut)
    */

    ifstream rom;
    rom.open((char *)name, std::ios_base::binary);

    /* 1. HEADER
    The header format is as follows:
    0-3: Constant $4E $45 $53 $1A
    4:  Size of PRG ROM in 16KB units (x)
    5:  Size of CHR ROM in 8KB units (y)
    6:  Flags 6  - Mapper, mirroring, battery, trainer
    7:  Flags 7  - Mapper, VS/Playchoice, NES 2.0
    8:  Flags 8  - PRG-RAM size
    9:  Flags 9  - TV system
    10: Flags 10 - TV system, PRG-RAM presence
    11-15: unused padding
    */
    char header[HEADER_SIZE];
    rom.read(header, HEADER_SIZE);
    
    int x = header[4];
    int y = header[5];

    /* 3. PRG ROM data */
    char prg_rom[PRG_ROM_SIZE*x];
    rom.read(prg_rom, PRG_ROM_SIZE*x);

    /* 4. CHR ROM data */
    rom.read((char *)ram, CHR_ROM_SIZE*y);
    rom.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x268(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x1130
movq -0x260(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x10b0
jmp 0x55a8
leaq -0x218(%rbp), %rdi
leaq -0x240(%rbp), %rsi
movl $0x10, %edx
callq 0x1150
jmp 0x55c2
movsbl -0x23c(%rbp), %eax
movl %eax, -0x244(%rbp)
movsbl -0x23b(%rbp), %eax
movl %eax, -0x248(%rbp)
movl -0x244(%rbp), %eax
shll $0xe, %eax
movq %rsp, %rcx
movq %rcx, -0x250(%rbp)
movq %rsp, %rsi
subq %rax, %rsi
movq %rsi, %rsp
movq %rax, -0x258(%rbp)
movl -0x244(%rbp), %eax
shll $0xe, %eax
movslq %eax, %rdx
leaq -0x218(%rbp), %rdi
callq 0x1150
jmp 0x5619
movq -0x268(%rbp), %rax
movq (%rax), %rsi
movl -0x248(%rbp), %eax
shll $0xd, %eax
movslq %eax, %rdx
leaq -0x218(%rbp), %rdi
callq 0x1150
jmp 0x563d
leaq -0x218(%rbp), %rdi
callq 0x1030
jmp 0x564b
movq -0x250(%rbp), %rax
movq %rax, %rsp
leaq -0x218(%rbp), %rdi
callq 0x1050
movq %rbp, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x1050
movq -0x220(%rbp), %rdi
callq 0x11c0
// File: NGageMegaman[P]NEScutre/src/mem_ppu.cpp
// Function: Mem_ppu::write_PPUADDR(unsigned char)
void Mem_ppu::write_PPUADDR(uint8_t addr) {
    if (ppuaddr_ptr_hl == 0) {
	//Writing high byte
	PPUADDR = (addr << 8);
	PPUADDR &= 0x3FFF; //Upper adddresses are mirrored
	ppuaddr_ptr_hl = 1;
    }
    else {
	//Writing low byte
	PPUADDR |= (addr & 0x00FF);
	ppuaddr_ptr_hl = 0;
    }
    //Lower bits of ppustatus are the last written bits
    PPUSTATUS = (PPUSTATUS & 0xe0) | (addr & 0x1f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x3c01c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5745
movq -0x18(%rbp), %rax
movzbl -0x9(%rbp), %ecx
shll $0x8, %ecx
movw %cx, 0x3c012(%rax)
movzwl 0x3c012(%rax), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
movw %cx, 0x3c012(%rax)
movb $0x1, 0x3c01c(%rax)
jmp 0x576a
movq -0x18(%rbp), %rax
movzbl -0x9(%rbp), %edx
andl $0xff, %edx
movzwl 0x3c012(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x3c012(%rax)
movb $0x0, 0x3c01c(%rax)
movq -0x18(%rbp), %rax
movzbl 0x3c015(%rax), %ecx
andl $0xe0, %ecx
movzbl -0x9(%rbp), %edx
andl $0x1f, %edx
orl %edx, %ecx
movb %cl, 0x3c015(%rax)
popq %rbp
retq
nopl (%rax)
// File: NGageMegaman[P]NEScutre/src/mem_ppu.cpp
// Function: Mem_ppu::read_PPUSTATUS()
uint8_t Mem_ppu::read_PPUSTATUS() {
    uint8_t result = PPUSTATUS;
    //Clear the vblank status bit if we are not in vblank
    if (!in_vblank)
	PPUSTATUS = PPUSTATUS & 0x7f;
    //Clear the address latch
    PPUADDR = 0;
    ppuaddr_ptr_hl = 0;
    ppuscroll_ptr_hl = 0;
    oamaddr_ptr_hl = 0;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x3c015(%rax), %cl
movb %cl, -0x9(%rbp)
testb $0x1, 0x3c01f(%rax)
jne 0x57c6
movq -0x18(%rbp), %rax
movzbl 0x3c015(%rax), %ecx
andl $0x7f, %ecx
movb %cl, 0x3c015(%rax)
movq -0x18(%rbp), %rax
movw $0x0, 0x3c012(%rax)
movb $0x0, 0x3c01c(%rax)
movb $0x0, 0x3c01e(%rax)
movb $0x0, 0x3c01d(%rax)
movb -0x9(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: NGageMegaman[P]NEScutre/src/mem_ppu.cpp
// Function: Mem_ppu::read_PPUDATA()
uint8_t Mem_ppu::read_PPUDATA() {
    uint8_t result;
    if (PPUADDR > 0x3eff) {
	//When ppuaddr is at the pallettes, read normally
	result = read_byte(PPUADDR);
	PPUDATA = result;
    }
    else {
	//If not, then read the internal buffer
	result = PPUDATA;
	PPUDATA = read_byte(PPUADDR);
    }
    //The internal buffer updates anyways

    if (((PPUCTRL >> 2) & 1) == 0) {
	    PPUADDR += 1;
    }
    else {
	    PPUADDR += 32;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl 0x3c012(%rax), %eax
cmpl $0x3eff, %eax           # imm = 0x3EFF
jle 0x5839
movq -0x18(%rbp), %rax
movq %rax, %rdi
movzwl 0x3c012(%rax), %esi
callq 0x52d0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, -0x9(%rbp)
movb -0x9(%rbp), %cl
movb %cl, 0x3c014(%rax)
jmp 0x5861
movq -0x18(%rbp), %rax
movb 0x3c014(%rax), %cl
movb %cl, -0x9(%rbp)
movq %rax, %rdi
movzwl 0x3c012(%rax), %esi
callq 0x52d0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3c014(%rax)
movq -0x18(%rbp), %rax
movzbl 0x3c010(%rax), %eax
sarl $0x2, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x588e
movq -0x18(%rbp), %rax
movzwl 0x3c012(%rax), %ecx
addl $0x1, %ecx
movw %cx, 0x3c012(%rax)
jmp 0x58a3
movq -0x18(%rbp), %rax
movzwl 0x3c012(%rax), %ecx
addl $0x20, %ecx
movw %cx, 0x3c012(%rax)
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: NGageMegaman[P]NEScutre/src/mem_ppu.cpp
// Function: Mem_ppu::write_PPUDATA(unsigned char)
void Mem_ppu::write_PPUDATA(uint8_t data) {
    write_byte(PPUADDR, data);
    if (((PPUCTRL >> 2) & 1) == 0) {
	    PPUADDR += 1;
    }
    else {
	    PPUADDR += 32;
    }
    //Lower bits of ppustatus are the last written bits
    PPUSTATUS = (PPUSTATUS & 0xe0) | (data & 0x1f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movw 0x3c012(%rdi), %ax
movzwl %ax, %esi
movzbl -0x9(%rbp), %edx
callq 0x5490
movq -0x18(%rbp), %rax
movzbl 0x3c010(%rax), %eax
sarl $0x2, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x590a
movq -0x18(%rbp), %rax
movzwl 0x3c012(%rax), %ecx
addl $0x1, %ecx
movw %cx, 0x3c012(%rax)
jmp 0x591f
movq -0x18(%rbp), %rax
movzwl 0x3c012(%rax), %ecx
addl $0x20, %ecx
movw %cx, 0x3c012(%rax)
movq -0x18(%rbp), %rax
movzbl 0x3c015(%rax), %ecx
andl $0xe0, %ecx
movzbl -0x9(%rbp), %edx
andl $0x1f, %edx
orl %edx, %ecx
movb %cl, 0x3c015(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NGageMegaman[P]NEScutre/src/mem_ppu.cpp
// Function: Mem_ppu::write_OAMADDR(unsigned char)
void Mem_ppu::write_OAMADDR(uint8_t addr) {
    if (oamaddr_ptr_hl == 0) {
	//Writing high byte
	OAMADDR = (addr << 8);
	OAMADDR &= 0x3FFF; //Upper adddresses are mirrored
	oamaddr_ptr_hl = 1;
    }
    else {
	//Writing low byte
	OAMADDR |= (addr & 0x00FF);
	oamaddr_ptr_hl = 0;
    }
    //Lower bits of ppustatus are the last written bits
    PPUSTATUS = (PPUSTATUS & 0xe0) | (addr & 0x1f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x3c01d(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x59a5
movq -0x18(%rbp), %rax
movzbl -0x9(%rbp), %ecx
shll $0x8, %ecx
movw %cx, 0x3c016(%rax)
movzwl 0x3c016(%rax), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
movw %cx, 0x3c016(%rax)
movb $0x1, 0x3c01d(%rax)
jmp 0x59ca
movq -0x18(%rbp), %rax
movzbl -0x9(%rbp), %edx
andl $0xff, %edx
movzwl 0x3c016(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x3c016(%rax)
movb $0x0, 0x3c01d(%rax)
movq -0x18(%rbp), %rax
movzbl 0x3c015(%rax), %ecx
andl $0xe0, %ecx
movzbl -0x9(%rbp), %edx
andl $0x1f, %edx
orl %edx, %ecx
movb %cl, 0x3c015(%rax)
popq %rbp
retq
nopl (%rax)
// File: NGageMegaman[P]NEScutre/src/mem_ppu.cpp
// Function: Mem_ppu::read_OAMDATA()
uint8_t Mem_ppu::read_OAMDATA() {
    uint8_t result = ram[OAMADDR];
    if (!in_vblank)
	OAMADDR = OAMADDR+1;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rcx
movzwl 0x3c016(%rax), %edx
movb (%rcx,%rdx), %cl
movb %cl, -0x9(%rbp)
testb $0x1, 0x3c01f(%rax)
jne 0x5a2e
movq -0x18(%rbp), %rax
movzwl 0x3c016(%rax), %ecx
addl $0x1, %ecx
movw %cx, 0x3c016(%rax)
movb -0x9(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NGageMegaman[P]NEScutre/src/mem_ppu.cpp
// Function: Mem_ppu::write_PPUSCROLL(unsigned char)
void Mem_ppu::write_PPUSCROLL(uint8_t data) {
    if (ppuscroll_ptr_hl == 0) {
	//Writing high byte
	PPUSCROLL = (data << 8);
	ppuscroll_ptr_hl = 1;
    }
    else {
	//Writing low byte
	PPUSCROLL |= (data & 0x00FF);
	ppuscroll_ptr_hl = 0;
    }
    //Lower bits of ppustatus are the last written bits
    PPUSTATUS = (PPUSTATUS & 0xe0) | (data & 0x1f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x3c01e(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5b51
movq -0x18(%rbp), %rax
movzbl -0x9(%rbp), %ecx
shll $0x8, %ecx
movw %cx, 0x3c01a(%rax)
movb $0x1, 0x3c01e(%rax)
jmp 0x5b76
movq -0x18(%rbp), %rax
movzbl -0x9(%rbp), %edx
andl $0xff, %edx
movzwl 0x3c01a(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x3c01a(%rax)
movb $0x0, 0x3c01e(%rax)
movq -0x18(%rbp), %rax
movzbl 0x3c015(%rax), %ecx
andl $0xe0, %ecx
movzbl -0x9(%rbp), %edx
andl $0x1f, %edx
orl %edx, %ecx
movb %cl, 0x3c015(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: NGageMegaman[P]NEScutre/src/ppu.cpp
// Function: Ppu::Ppu()
Ppu::Ppu() {
    di = XOpenDisplay(getenv("DISPLAY"));
    //Create window
    int x = 0, y = 0, width = 256, height = 240, border_width = 1;
    sc = DefaultScreen(di);
    ro = DefaultRootWindow(di);
    wi = XCreateSimpleWindow(di, ro, x, y, width, height, border_width, BlackPixel(di, sc), WhitePixel(di, sc));
    XSelectInput(di, wi, KeyPressMask | KeyReleaseMask | ExposureMask);
    XAutoRepeatOff(di);
    gc = XCreateGC(di, ro, 0, NULL);
    XMapWindow(di, wi); //Make window visible
    XStoreName(di, wi, "NEScutre");
    initColors();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rbx
movq %rbx, -0x30(%rbp)
leaq 0x1961(%rip), %rdi      # 0x754d
callq 0x1140
movq %rax, %rdi
callq 0x1180
movq %rax, 0x10(%rbx)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x100, -0x1c(%rbp)     # imm = 0x100
movl $0xf0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq 0x10(%rbx), %rax
movl 0xe0(%rax), %eax
movl %eax, 0x18(%rbx)
movq 0x10(%rbx), %rax
movq 0xe8(%rax), %rax
movq 0x10(%rbx), %rcx
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rbx)
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %r9d
movl -0x24(%rbp), %r11d
movq 0x10(%rbx), %rax
movq 0xe8(%rax), %rax
movslq 0x18(%rbx), %r10
shlq $0x7, %r10
addq %r10, %rax
movq 0x60(%rax), %r10
movq 0x10(%rbx), %rax
movq 0xe8(%rax), %rax
movslq 0x18(%rbx), %rbx
shlq $0x7, %rbx
addq %rbx, %rax
movq 0x58(%rax), %rax
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x1060
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rax), %rdi
movq 0x28(%rax), %rsi
movl $0x8003, %edx           # imm = 0x8003
callq 0x10a0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10c0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rax), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1090
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rax), %rdi
movq 0x28(%rax), %rsi
callq 0x1120
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rax), %rsi
leaq 0x1835(%rip), %rdx      # 0x7555
callq 0x1040
movq -0x30(%rbp), %rdi
callq 0x5d40
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NGageMegaman[P]NEScutre/src/ppu.cpp
// Function: Ppu::checkSprite0Hit(int)
void Ppu::checkSprite0Hit(int n_scanline) {
    int pos_y = mem_ppu->oam[0];
    
    if (n_scanline == pos_y) {
        if (pos_y == n_scanline) {
	    mem_ppu->PPUSTATUS |= 0x40;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x5feb
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x5fe9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0x3c015(%rax), %ecx
orl $0x40, %ecx
movb %cl, 0x3c015(%rax)
jmp 0x5feb
popq %rbp
retq
nopl (%rax)
// File: NGageMegaman[P]NEScutre/src/ppu.cpp
// Function: Ppu::vblank()
void Ppu::vblank() {
    //Set the vblank bit
    mem_ppu->PPUSTATUS = mem_ppu->PPUSTATUS | 0x80;
    mem_ppu->in_vblank = true;
    if ((mem_ppu->PPUCTRL >> 7) & 1)
	cpu->NMI_execute();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rcx
movzbl 0x3c015(%rcx), %ecx
orl $0x80, %ecx
movb %cl, %dl
movq 0x8(%rax), %rcx
movb %dl, 0x3c015(%rcx)
movq 0x8(%rax), %rcx
movb $0x1, 0x3c01f(%rcx)
movq 0x8(%rax), %rax
movzbl 0x3c010(%rax), %eax
sarl $0x7, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x68fe
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4350
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: araujoigor[P]ipp-compiler/./src/include/IMath.hpp
// Function: IMath::isNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static bool isNumber(std::string numberStr){
		try{
			std::string::size_type sz;
			std::stof(numberStr, &sz);
			return true;
		}catch(std::invalid_argument& e){
			return false;
		}catch(std::out_of_range& ex){
			std::cout << "Erro ao avaliar string " << numberStr << std::endl;
			return false;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xf400
jmp 0xda5b
movb $0x1, -0x1(%rbp)
jmp 0xdb0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xda97
movq -0x20(%rbp), %rdi
callq 0x9210
movq %rax, -0x38(%rbp)
movb $0x0, -0x1(%rbp)
callq 0x9970
jmp 0xdb0e
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xdb19
movq -0x20(%rbp), %rdi
callq 0x9210
movq %rax, -0x30(%rbp)
movq 0x74511(%rip), %rdi     # 0x81fc8
leaq 0x4f9a3(%rip), %rsi     # 0x5d461
callq 0x9500
movq %rax, -0x50(%rbp)
jmp 0xdac9
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x9490
movq %rax, -0x58(%rbp)
jmp 0xdadc
movq -0x58(%rbp), %rdi
movq 0x744b1(%rip), %rsi     # 0x81f98
callq 0x95a0
jmp 0xdaee
movb $0x0, -0x1(%rbp)
callq 0x9970
jmp 0xdb0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9970
jmp 0xdb0c
jmp 0xdb19
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9a90
movq %rax, %rdi
callq 0xf440
nopw (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IDefinition.hpp
// Function: IDefinition::addVar(IData*)
void addVar(IData *var){
		vars.push_back(var);

		if(ownerBlock == NULL)
			scheduledVariableRegister = true;
		else
			ownerBlock->registerLocalVariable(var, myLine);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x38, %rdi
leaq -0x10(%rbp), %rsi
callq 0x14a40
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xdedd
movq -0x18(%rbp), %rax
movb $0x1, 0xb0(%rax)
jmp 0xdef1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movl 0x8(%rax), %edx
callq 0x14890
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IDefinition.hpp
// Function: IDefinition::addVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void addVar(std::string *leftVar, std::string *rightVar){
		varEqualsVarMapping[*leftVar] = *rightVar;

		if(ownerBlock == NULL)
			scheduledVariableRegister = true;
		else
			ownerBlock->registerLocalVariable(generateVariable(&type, leftVar), myLine);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x15140
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x9060
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xdf55
movq -0x20(%rbp), %rax
movb $0x1, 0xb0(%rax)
jmp 0xdf81
movq -0x20(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x9ff0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x14890
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IMath.hpp
// Function: IMath::IMath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
IMath(std::string *newExpression){
		expression.clear();
		expression.push_back('(');
		expression.append(*newExpression);
		expression.push_back(')');
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x97d0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x30(%rbp)
callq 0x16110
movq -0x28(%rbp), %rdi
movl $0x0, 0x38(%rdi)
movl $0x1, 0x3c(%rdi)
callq 0x9760
movq -0x28(%rbp), %rdi
movl $0x28, %esi
callq 0x9460
jmp 0xdfec
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9bc0
jmp 0xdffb
movq -0x38(%rbp), %rdi
movl $0x29, %esi
callq 0x9460
jmp 0xe00b
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x16130
movq -0x28(%rbp), %rdi
callq 0x9c30
movq -0x18(%rbp), %rdi
callq 0x9a90
nopl (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IDefinition.hpp
// Function: IDefinition::addVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, IMath*)
void addVar(std::string *leftValue, IMath *rightVar){
		varEqualsMathMapping[*leftValue] = rightVar;

		if(ownerBlock == NULL)
			scheduledVariableRegister = true;
		else
			ownerBlock->registerLocalVariable(generateVariable(&type, leftValue), myLine);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x80, %rdi
movq -0x10(%rbp), %rsi
callq 0x163d0
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rdx, (%rcx)
cmpq $0x0, 0x10(%rax)
jne 0xe0f6
movq -0x20(%rbp), %rax
movb $0x1, 0xb0(%rax)
jmp 0xe122
movq -0x20(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x9ff0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x14890
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IMath.hpp
// Function: IMath::isInteger(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static bool isInteger(std::string numberStr){
		if(isNumber(numberStr)){
			if(numberStr.find(".") != std::string::npos || numberStr.find("e") != std::string::npos ||
					numberStr.find("E") != std::string::npos)
				return false;

			return true;
		}

		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, %rsi
movq %rsi, -0x50(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x9240
movq -0x48(%rbp), %rdi
callq 0xda40
movb %al, -0x3d(%rbp)
jmp 0xe33e
leaq -0x30(%rbp), %rdi
callq 0x9c30
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0xe350
jmp 0xe3c1
movq -0x50(%rbp), %rdi
leaq 0x5380f(%rip), %rsi     # 0x61b6a
xorl %eax, %eax
movl %eax, %edx
callq 0x9be0
cmpq $-0x1, %rax
jne 0xe39e
movq -0x50(%rbp), %rdi
leaq 0x4f3a6(%rip), %rsi     # 0x5d71b
xorl %eax, %eax
movl %eax, %edx
callq 0x9be0
cmpq $-0x1, %rax
jne 0xe39e
movq -0x50(%rbp), %rdi
leaq 0x4f1c7(%rip), %rsi     # 0x5d556
xorl %eax, %eax
movl %eax, %edx
callq 0x9be0
cmpq $-0x1, %rax
je 0xe3bb
movb $0x0, -0x1(%rbp)
jmp 0xe3c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9c30
jmp 0xe3d0
movb $0x1, -0x1(%rbp)
jmp 0xe3c5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x9a90
nopl (%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IAssignment.hpp
// Function: IAssignment::IAssignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int, int)
IAssignment(std::string* leftVariableId, int value, int myline) : IStatement(myline){
	  this->leftVariableId = new std::string(*leftVariableId);
	  rightValueInt = value;
	  rightIsValue = true;
	  rightIsInteger = true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x18(%rbp), %esi
callq 0x104b0
movq -0x38(%rbp), %rax
leaq 0x72c67(%rip), %rcx     # 0x81078
movq %rcx, (%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movl $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movb $0x0, 0x58(%rax)
movb $0x0, 0x59(%rax)
movb $0x0, 0x5a(%rax)
movb $0x0, 0x5b(%rax)
movl $0x20, %edi
callq 0x9510
movq %rax, -0x30(%rbp)
jmp 0xe473
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9240
jmp 0xe482
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x48(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x30(%rax)
movb $0x1, 0x59(%rax)
movb $0x1, 0x58(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xe4c5
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x94c0
movq -0x38(%rbp), %rdi
callq 0x11b20
movq -0x20(%rbp), %rdi
callq 0x9a90
nopw (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IFlowControl.hpp
// Function: IFlowControl::IFlowControl(IBlock*, IBlock*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int)
IFlowControl(IBlock* newIfBlock, IBlock* newElseBlock, string* exp, int myline) : IStatement(myline){
		ifBlock = newIfBlock;
		elseBlock = newElseBlock;
		expression = exp;

		if(ifBlock != NULL)
			ifBlock->setStatementOwner(this);

		if(elseBlock != NULL)
			elseBlock->setStatementOwner(this);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0x24(%rbp), %esi
callq 0x104b0
movq -0x40(%rbp), %rax
leaq 0x72919(%rip), %rcx     # 0x810b0
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x20(%rax)
je 0xe7f5
movq -0x40(%rbp), %rsi
movq 0x20(%rsi), %rdi
callq 0x18df0
jmp 0xe7dc
jmp 0xe7f5
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x11b20
jmp 0xe817
movq -0x40(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xe811
movq -0x40(%rbp), %rsi
movq 0x28(%rsi), %rdi
callq 0x18df0
jmp 0xe80f
jmp 0xe811
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x9a90
// File: araujoigor[P]ipp-compiler/./src/include/IFlowControl.hpp
// Function: IFlowControl::addElseSingleStatement(IStatement*)
void addElseSingleStatement(IStatement *stmt){
		if(elseBlock == NULL && stmt != NULL){
			elseBlock = new IBlock();
			elseBlock->addStatement(stmt);
			stmt->setOwnerBlock(elseBlock);
			elseBlock->setStatementOwner(this);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x28(%rax)
jne 0xe8b2
cmpq $0x0, -0x10(%rbp)
je 0xe8b2
movl $0x40, %edi
callq 0x9510
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xdd00
jmp 0xe861
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdd60
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x28(%rbp), %rsi
movq 0x28(%rsi), %rdi
callq 0x18df0
jmp 0xe8b2
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x94c0
jmp 0xe8b8
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x9a90
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IFlowControl.hpp
// Function: IFlowControl::addIfSingleStatement(IStatement*)
void addIfSingleStatement(IStatement *stmt){
		if(ifBlock == NULL && stmt != NULL){
			ifBlock = new IBlock();
			ifBlock->addStatement(stmt);
			stmt->setOwnerBlock(ifBlock);
			ifBlock->setStatementOwner(this);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0xe962
cmpq $0x0, -0x10(%rbp)
je 0xe962
movl $0x40, %edi
callq 0x9510
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xdd00
jmp 0xe911
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdd60
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x28(%rbp), %rsi
movq 0x20(%rsi), %rdi
callq 0x18df0
jmp 0xe962
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x94c0
jmp 0xe968
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x9a90
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IWhile.hpp
// Function: IWhile::IWhile(IBlock*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int)
IWhile(IBlock *block, string *exp, int myline) :
			IStatement(myline) {
		innerBlock = block;
		expression = exp;

		if (innerBlock != NULL)
			innerBlock->setStatementOwner(this);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x1c(%rbp), %esi
callq 0x104b0
movq -0x28(%rbp), %rax
leaq 0x73246(%rip), %rcx     # 0x81bf8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x20(%rax)
je 0xe9dd
movq -0x28(%rbp), %rsi
movq 0x20(%rsi), %rdi
callq 0x18df0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IWhile.hpp
// Function: IWhile::addSingleStatement(IStatement*)
void addSingleStatement(IStatement *stmt) {
		if (innerBlock == NULL && stmt != NULL) {
			innerBlock = new IBlock();
			innerBlock->addStatement(stmt);
			stmt->setOwnerBlock(innerBlock);
			innerBlock->setStatementOwner(this);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0xea82
cmpq $0x0, -0x10(%rbp)
je 0xea82
movl $0x40, %edi
callq 0x9510
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xdd00
jmp 0xea31
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdd60
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x28(%rbp), %rsi
movq 0x20(%rsi), %rdi
callq 0x18df0
jmp 0xea82
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x94c0
jmp 0xea88
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x9a90
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IRepeat.hpp
// Function: IRepeat::addSingleStatement(IStatement*)
void addSingleStatement(IStatement *stmt){
		if(innerBlock == NULL && stmt != NULL){
			innerBlock = new IBlock();
			innerBlock->addStatement(stmt);
			stmt->setOwnerBlock(innerBlock);
			innerBlock->setStatementOwner(this);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x28(%rax)
jne 0xed62
cmpq $0x0, -0x10(%rbp)
je 0xed62
movl $0x40, %edi
callq 0x9510
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xdd00
jmp 0xed11
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdd60
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x28(%rbp), %rsi
movq 0x28(%rsi), %rdi
callq 0x18df0
jmp 0xed62
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x94c0
jmp 0xed68
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x9a90
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IDefinition.hpp
// Function: IDefinition::setOwnerBlock(IBlock*)
void setOwnerBlock(IBlock *newOwnerBlock){
		IStatement::setOwnerBlock(newOwnerBlock);
		if(scheduledVariableRegister){
			for(ulong i = 0; i < vars.size(); i++){
				newOwnerBlock->registerLocalVariable(vars[i], myLine);
			}

			for(auto it = varEqualsVarMapping.begin(); it != varEqualsVarMapping.end(); ++it){
				newOwnerBlock->registerLocalVariable(generateVariable(&type, ((std::string *)&it->first)), myLine);
			}

			for(auto it = varEqualsMathMapping.begin(); it != varEqualsMathMapping.end(); ++it){
				newOwnerBlock->registerLocalVariable(generateVariable(&type, ((std::string *)&it->first)), myLine);
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x11b50
movq -0x40(%rbp), %rax
testb $0x1, 0xb0(%rax)
je 0x11b18
movq $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x38, %rdi
callq 0x126c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x11a18
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x126e0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq (%rcx), %rsi
movl 0x8(%rax), %edx
callq 0x14890
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x119ba
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x12750
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x127b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12780
testb $0x1, %al
jne 0x11a4d
jmp 0x11a94
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x58(%rbp)
addq $0x18, %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x12940
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x9ff0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movq -0x40(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x14890
leaq -0x20(%rbp), %rdi
callq 0x12ce0
jmp 0x11a29
movq -0x40(%rbp), %rdi
addq $0x80, %rdi
callq 0x12d10
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
addq $0x80, %rdi
callq 0x12d70
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12d40
testb $0x1, %al
jne 0x11acf
jmp 0x11b16
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x68(%rbp)
addq $0x18, %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x12da0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x9ff0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movq -0x40(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x14890
leaq -0x30(%rbp), %rdi
callq 0x136b0
jmp 0x11aa8
jmp 0x11b18
addq $0x70, %rsp
popq %rbp
retq
nop
// File: araujoigor[P]ipp-compiler/./src/include/IBlock.hpp
// Function: IBlock::getLocalVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
IData* getLocalVariable(std::string variableId){
		for(ulong i = 0; i < blockVariables.size(); i++){

			if(blockVariables[i]->getId() == variableId)
				return blockVariables[i];
		}

		/* Caso o bloco local não possua a variavel, perguntamos aos blocos pai */
		if(stmtOwner != NULL){
			return stmtOwner->getOwnerBlock()->getLocalVariable(variableId);
		}

		return NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x8, %rdi
callq 0x126c0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x128a3
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x126e0
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x12700
movq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x13620
movb %al, -0x89(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9c30
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x12873
jmp 0x12890
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x126e0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12927
jmp 0x12892
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x12807
movq -0x78(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1291f
movq -0x78(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x13760
movq -0x80(%rbp), %rsi
movq %rax, -0xa8(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x9240
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x127e0
movq %rax, -0x98(%rbp)
jmp 0x128f2
movq -0x98(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9c30
jmp 0x12927
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9c30
jmp 0x12934
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x9a90
nopl (%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IBlock.hpp
// Function: IBlock::registerLocalVariable(IData*, int)
void registerLocalVariable(IData* var, int myLine) {
		if(getLocalVariable(var->getId()) != NULL){
			std::string errorMsg = "Variavel referenciada ja existente.";
			throw ISourceErrorException(errorMsg, myLine);
		}
		blockVariables.push_back(var);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x12700
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x127e0
movq %rax, -0xa0(%rbp)
jmp 0x148e1
leaq -0x38(%rbp), %rdi
callq 0x9c30
movq -0xa0(%rbp), %rax
cmpq $0x0, %rax
je 0x14a0b
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x9ab0
movq -0xb8(%rbp), %rdx
leaq 0x49180(%rip), %rsi     # 0x5da99
leaq -0x68(%rbp), %rdi
callq 0x97c0
jmp 0x14924
leaq -0x69(%rbp), %rdi
callq 0x95e0
movb $0x1, -0x91(%rbp)
movl $0x28, %edi
callq 0x9290
movq %rax, -0xc0(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9240
jmp 0x14957
movq -0xc0(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x90(%rbp), %rsi
callq 0x12a70
jmp 0x1496f
movq -0xc0(%rbp), %rdi
movb $0x0, -0x91(%rbp)
leaq 0x6c6d4(%rip), %rsi     # 0x81058
leaq -0x1eab(%rip), %rdx     # 0x12ae0
callq 0x9a20
jmp 0x14a31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9c30
jmp 0x14a28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x95e0
jmp 0x14a28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x149e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x9c30
testb $0x1, -0x91(%rbp)
jne 0x149f4
jmp 0x14a00
movq -0xc0(%rbp), %rdi
callq 0x9400
leaq -0x68(%rbp), %rdi
callq 0x9c30
jmp 0x14a28
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x14a40
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x9a90
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: araujoigor[P]ipp-compiler/./src/include/IAssignment.hpp
// Function: IAssignment::~IAssignment()
virtual ~IAssignment(){
	  delete leftVariable;
	  delete rightVariable;
	  delete rightStrValue;
	  delete rightVariableMath;
	  delete leftVariableId;
	  delete rightVariableId;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x68b6d(%rip), %rcx     # 0x81068
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1851a
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x18536
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1855a
movq -0x28(%rbp), %rdi
callq 0x9c30
movq -0x28(%rbp), %rdi
callq 0x94c0
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1857e
movq -0x30(%rbp), %rdi
callq 0x18dc0
movq -0x30(%rbp), %rdi
callq 0x94c0
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x185a2
movq -0x38(%rbp), %rdi
callq 0x9c30
movq -0x38(%rbp), %rdi
callq 0x94c0
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x185c6
movq -0x40(%rbp), %rdi
callq 0x9c30
movq -0x40(%rbp), %rdi
callq 0x94c0
movq -0x18(%rbp), %rdi
callq 0x11b20
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: araujoigor[P]ipp-compiler/./src/include/IBlock.hpp
// Function: IBlock::generateRandomVariableName[abi:cxx11](unsigned long)
static std::string generateRandomVariableName( size_t length )
	{
	    auto randchar = []() -> char
	    {
	        const char charset[] =
	        "0123456789"
	        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	        "abcdefghijklmnopqrstuvwxyz";
	        const size_t max_index = (sizeof(charset) - 1);
	        return charset[ rand() % max_index ];
	    };
	    std::string str(length,0);
	    std::generate_n( str.begin(), length, randchar );
	    return str;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x13(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x9ab0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
xorl %edx, %edx
callq 0x93b0
jmp 0x57eb9
leaq -0x13(%rbp), %rdi
callq 0x95e0
movq -0x58(%rbp), %rdi
callq 0x9470
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x57f40
movq %rax, -0x68(%rbp)
jmp 0x57ee2
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x57f2d
jmp 0x57f24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x13(%rbp), %rdi
callq 0x95e0
jmp 0x57f37
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9c30
jmp 0x57f37
movq -0x58(%rbp), %rdi
callq 0x9c30
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9a90
// File: araujoigor[P]ipp-compiler/./src/include/IRead.hpp
// Function: IRead::generateCode(std::basic_fstream<char, std::char_traits<char>>&)
void generateCode(std::fstream& fileStream) {

		/* Um leia é representado por um cin */
		fileStream << "cin >> ";

		/* Obtemos a variável especificada, a partir dos blocos "pai" */
		IData *data = ownerBlock->getLocalVariable(varId);

		/* Se a variável não existir, geramos um erro. */
		 if(data == NULL){
			 std::string errorMsg = "Variavel \'" + *varId + "\' nao declarada.";
			 throw ISourceErrorException(errorMsg, myLine);
		 }

		 fileStream << *varId << ";" << endl;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x957e(%rip), %rsi      # 0x61b7b
callq 0x9500
movq -0x98(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rsi
callq 0x18610
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5873a
movq -0x98(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x954c(%rip), %rsi      # 0x61b83
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x12960
movq -0xa0(%rbp), %rsi
leaq 0x9539(%rip), %rdx      # 0x61b8e
leaq -0x38(%rbp), %rdi
callq 0x123f0
jmp 0x58660
leaq -0x58(%rbp), %rdi
callq 0x9c30
movb $0x1, -0x89(%rbp)
movl $0x28, %edi
callq 0x9290
movq %rax, -0xa8(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9240
jmp 0x58693
movq -0xa8(%rbp), %rdi
movq -0x98(%rbp), %rax
movl 0x8(%rax), %edx
leaq -0x88(%rbp), %rsi
callq 0x12a70
jmp 0x586b2
movq -0xa8(%rbp), %rdi
movb $0x0, -0x89(%rbp)
leaq 0x28991(%rip), %rsi     # 0x81058
leaq -0x45bee(%rip), %rdx    # 0x12ae0
callq 0x9a20
jmp 0x58782
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9c30
jmp 0x58779
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x58718
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x9c30
testb $0x1, -0x89(%rbp)
jne 0x58723
jmp 0x5872f
movq -0xa8(%rbp), %rdi
callq 0x9400
leaq -0x38(%rbp), %rdi
callq 0x9c30
jmp 0x58779
movq -0x98(%rbp), %rax
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq 0x18(%rax), %rsi
callq 0x9490
movq %rax, %rdi
leaq 0x944b(%rip), %rsi      # 0x61ba7
callq 0x9500
movq %rax, %rdi
movq 0x2982d(%rip), %rsi     # 0x81f98
callq 0x95a0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x9a90
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: araujoigor[P]ipp-compiler/src/generated/tokens.cpp
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 98 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 97);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x28962(%rip), %rax     # 0x82a30
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x854f(%rip), %rax      # 0x62630
cmpw $0x0, (%rax,%rcx,2)
je 0x5a0fc
movl -0x4(%rbp), %eax
movl %eax, 0x2894b(%rip)     # 0x82a3c
movq -0x10(%rbp), %rax
movq %rax, 0x28944(%rip)     # 0x82a40
jmp 0x5a0fe
movslq -0x4(%rbp), %rcx
leaq 0x8757(%rip), %rax      # 0x62860
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x85e3(%rip), %rax      # 0x62700
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x5a153
movslq -0x4(%rbp), %rcx
leaq 0x87ff(%rip), %rax      # 0x62930
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x62, -0x4(%rbp)
jl 0x5a151
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x88b5(%rip), %rax      # 0x62a00
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x5a0fe
movslq -0x4(%rbp), %rcx
leaq 0x8702(%rip), %rax      # 0x62860
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x88be(%rip), %rax      # 0x62a30
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x61, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x5a195
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x5a19b
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: milzar[P]Multiplayer-Hangman-Game/src/hangman/GameData.cpp
// Function: GameData::init(int)
void GameData::init(int root_word_len) {
    word_length = root_word_len;
    memset(current_string, '_', word_length);
    current_string[word_length] = '\0';

    n_players = 2;
    current_turn = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq %rax, %rdi
addq $0x4, %rdi
movslq (%rax), %rdx
movl $0x5f, %esi
callq 0x31a0
movq -0x18(%rbp), %rax
movslq (%rax), %rcx
movb $0x0, 0x4(%rax,%rcx)
movl $0x2, 0x18(%rax)
movl $0x0, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: milzar[P]Multiplayer-Hangman-Game/src/hangman/GameData.cpp
// Function: GameData::play(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 GameData::play(std::string root_word, std::string str) {
    int len = str.size();

    // std::cout<<"playing "<<str<<"on "<<root_word<<std::endl;
    // The word is being guessed
    if(len != 1) {
        return str == root_word;
    }

    // A letter is being guessed
    char letter = str[0];
    bool game_finished = true;

    for(int i = 0; i < word_length; ++i) {
        if(root_word[i] == letter) {
            current_string[i] = letter;
        }
        if(current_string[i] == '_') {
            game_finished = false;
        }
    }
    return game_finished;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, %rax
movq -0x50(%rbp), %rdi
movq %rsi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x31f0
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
je 0x5a14
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x5ee0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x5a91
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34d0
movb (%rax), %al
movb %al, -0x25(%rbp)
movb $0x1, -0x26(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x5a86
movq -0x48(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x34d0
movsbl (%rax), %eax
movsbl -0x25(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5a63
movq -0x38(%rbp), %rax
movb -0x25(%rbp), %dl
movslq -0x2c(%rbp), %rcx
movb %dl, 0x4(%rax,%rcx)
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl 0x4(%rax,%rcx), %eax
cmpl $0x5f, %eax
jne 0x5a79
movb $0x0, -0x26(%rbp)
jmp 0x5a7b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5a31
movb -0x26(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)