LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: KellerMartins[P]PDS2-Pacman/source/game/game.cpp
// Function: Game::LevelClearedStateUpdate()
void LevelClearedStateUpdate(){
        if(stateTimer < 4){
            std::ostringstream scoreString;
            scoreString << "Score:" << pacman->GetPontuacao();
            UI::DrawTextCentered(scoreString.str(), 0.5, 0.05, 5, 0.5, RAYWHITE);
            UI::DrawTextCentered("Level Cleared!", 0.5, 0.5, 15, 0.0, WHITE);
            GameEvents::TriggerMenuUpdate();
        }else{
            Mapa::Recarrega();
            GameEvents::TriggerRestart();
            SetState(GameStart);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movsd 0x974d5(%rip), %xmm0    # 0xa5228
ucomisd 0xdd145(%rip), %xmm0    # 0xeaea0
jbe 0xdf49
leaq -0x178(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x9b10
movq -0x1e8(%rbp), %rdi
leaq 0x97547(%rip), %rsi     # 0xa52c9
callq 0x9890
movq %rax, -0x1e0(%rbp)
jmp 0xdd90
movq 0xdd101(%rip), %rdi     # 0xeae98
callq 0x147f0
movl %eax, -0x1ec(%rbp)
jmp 0xdda4
movl -0x1ec(%rbp), %esi
movq -0x1e0(%rbp), %rdi
callq 0x9af0
jmp 0xddb8
leaq -0x1a8(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x9900
jmp 0xddcd
movb $-0xb, -0x1ac(%rbp)
movb $-0xb, -0x1ab(%rbp)
movb $-0xb, -0x1aa(%rbp)
movb $-0x1, -0x1a9(%rbp)
movl -0x1ac(%rbp), %esi
leaq -0x1a8(%rbp), %rdi
movss 0x973f6(%rip), %xmm1    # 0xa51f4
movss 0x9720e(%rip), %xmm2    # 0xa5014
movss 0x973d2(%rip), %xmm3    # 0xa51e0
movaps %xmm3, %xmm0
callq 0x1a750
jmp 0xde18
leaq -0x1a8(%rbp), %rdi
callq 0x9530
leaq -0x1d1(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x9f60
movq -0x1f8(%rbp), %rdx
leaq 0x974ac(%rip), %rsi     # 0xa52f1
leaq -0x1d0(%rbp), %rdi
callq 0x9b20
jmp 0xde53
movb $-0x1, -0x1d5(%rbp)
movb $-0x1, -0x1d4(%rbp)
movb $-0x1, -0x1d3(%rbp)
movb $-0x1, -0x1d2(%rbp)
movl -0x1d5(%rbp), %esi
leaq -0x1d0(%rbp), %rdi
movss 0x9735c(%rip), %xmm1    # 0xa51e0
movss 0x97374(%rip), %xmm2    # 0xa5200
xorps %xmm3, %xmm3
movaps %xmm1, %xmm0
callq 0x1a750
jmp 0xde99
leaq -0x1d0(%rbp), %rdi
callq 0x9530
leaq -0x1d1(%rbp), %rdi
callq 0x9960
callq 0xe4a0
jmp 0xdeb8
leaq -0x178(%rbp), %rdi
callq 0x91c0
jmp 0xdf5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
jmp 0xdf3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x9530
jmp 0xdf3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
jmp 0xdf2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x9530
leaq -0x1d1(%rbp), %rdi
callq 0x9960
leaq -0x178(%rbp), %rdi
callq 0x91c0
jmp 0xdf66
callq 0x101d0
callq 0xe5a0
movl $0x2, %edi
callq 0xd4d0
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x180(%rbp), %rdi
callq 0x9f50
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/game/gameEvents.cpp
// Function: GameEvents::~GameEvents()
GameEvents::~GameEvents(){
    for(unsigned i=0; i<_events.size(); i++){
        //Remove "this" from the vector, doesn't maintain order
        if(_events[i] == this){
            _events[i] = _events[_events.size()-1];
            _events.pop_back();
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xd93e5(%rip), %rcx     # 0xe7a60
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
leaq 0xdc839(%rip), %rdi     # 0xeaed0
callq 0xe8f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0xe71e
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0xdc81c(%rip), %rdi     # 0xeaed0
callq 0xe910
movq -0x18(%rbp), %rcx
cmpq %rcx, (%rax)
jne 0xe70e
leaq 0xdc807(%rip), %rdi     # 0xeaed0
callq 0xe8f0
movq %rax, %rsi
subq $0x1, %rsi
leaq 0xdc7f4(%rip), %rdi     # 0xeaed0
callq 0xe910
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0xdc7dc(%rip), %rdi     # 0xeaed0
callq 0xe910
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
leaq 0xdc7c9(%rip), %rdi     # 0xeaed0
callq 0xe930
jmp 0xe71e
jmp 0xe710
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe689
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::RegistraMapaRenderizavel()
void Mapa::RegistraMapaRenderizavel(){
	for(int y = 0; y < ALTURA; y++){
		for(int x = 0; x < LARGURA; x++){
			int indiceElem = (int)(this->_mapa[x][y]);
			if(indiceElem < (int)(sizeof(modeloElemento)/sizeof(modeloElemento[0])) && modeloElemento[indiceElem] != ""){
				Object3D* parede = new Object3D(modeloElemento[indiceElem], BLUE);
				parede->position.x = x;
				parede->position.z = y;
				_objetosMapa.push_back(parede);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1b, -0xc(%rbp)
jge 0xf9e7
movl $0x0, -0x10(%rbp)
cmpl $0x15, -0x10(%rbp)
jge 0xf9d7
movq -0x60(%rbp), %rax
addq $0x8, %rax
movslq -0x10(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xf9c7
movslq -0x14(%rbp), %rax
leaq 0xdb628(%rip), %rdi     # 0xeaf00
shlq $0x5, %rax
addq %rax, %rdi
leaq 0x95aa8(%rip), %rsi     # 0xa538e
callq 0x11140
testb $0x1, %al
jne 0xf8f4
jmp 0xf9c7
movl $0x2b8, %edi            # imm = 0x2B8
callq 0x98b0
movq %rax, -0x68(%rbp)
movb $0x1, -0x51(%rbp)
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
leaq 0xdb5eb(%rip), %rsi     # 0xeaf00
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x93b0
jmp 0xf923
movq -0x68(%rbp), %rdi
movb $0x0, -0x50(%rbp)
movb $0x79, -0x4f(%rbp)
movb $-0xf, -0x4e(%rbp)
movb $-0x1, -0x4d(%rbp)
movl -0x50(%rbp), %edx
leaq -0x40(%rbp), %rsi
callq 0x15d20
jmp 0xf945
movb $0x0, -0x51(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9530
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
cvtsi2ssl -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x10(%rax)
cvtsi2ssl -0xc(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x18(%rax)
addq $0x11c8, %rdi           # imm = 0x11C8
leaq -0x20(%rbp), %rsi
callq 0x110d0
jmp 0xf9c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xf9af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9530
testb $0x1, -0x51(%rbp)
jne 0xf9b7
jmp 0xf9c5
movq -0x68(%rbp), %rdi
movl $0x2b8, %esi            # imm = 0x2B8
callq 0x98e0
jmp 0xf9ed
jmp 0xf9c9
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xf89c
jmp 0xf9d9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf88b
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x9f50
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::Recarrega()
void Mapa::Recarrega(){
	Mapa &mapa = GetMapaGlobal();
	for(int y = 0; y < ALTURA; y++){
		for(int x = 0; x < LARGURA; x++){
			ElementoMapa elem = mapa._original[x][y];
			mapa._mapa[x][y] = elem;

			if(elem == Ponto || elem == Especial){
				mapa._pontosRestantes++;
				Object3D* ponto = new Object3D(modeloElemento[elem], BLUE);
				ponto->position.x = x;
				ponto->position.z = y;
				mapa._objetosMapa.push_back(ponto);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
callq 0xf2d0
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1b, -0xc(%rbp)
jge 0x10353
movl $0x0, -0x10(%rbp)
cmpl $0x15, -0x10(%rbp)
jge 0x10343
movq -0x8(%rbp), %rax
addq $0x8e4, %rax            # imm = 0x8E4
movslq -0x10(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
addq $0x8, %rax
movslq -0x10(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x2, -0x14(%rbp)
je 0x1024f
cmpl $0x3, -0x14(%rbp)
jne 0x10333
movq -0x8(%rbp), %rax
movl 0x11c0(%rax), %ecx
incl %ecx
movl %ecx, 0x11c0(%rax)
movl $0x2b8, %edi            # imm = 0x2B8
callq 0x98b0
movq %rax, -0x60(%rbp)
movb $0x1, -0x51(%rbp)
movl -0x14(%rbp), %eax
shlq $0x5, %rax
leaq 0xdac7f(%rip), %rsi     # 0xeaf00
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x93b0
jmp 0x1028f
movq -0x60(%rbp), %rdi
movb $0x0, -0x50(%rbp)
movb $0x79, -0x4f(%rbp)
movb $-0xf, -0x4e(%rbp)
movb $-0x1, -0x4d(%rbp)
movl -0x50(%rbp), %edx
leaq -0x40(%rbp), %rsi
callq 0x15d20
jmp 0x102b1
movb $0x0, -0x51(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9530
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
cvtsi2ssl -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x10(%rax)
cvtsi2ssl -0xc(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x11c8, %rdi           # imm = 0x11C8
leaq -0x20(%rbp), %rsi
callq 0x110d0
jmp 0x10333
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1031b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9530
testb $0x1, -0x51(%rbp)
jne 0x10323
jmp 0x10331
movq -0x60(%rbp), %rdi
movl $0x2b8, %esi            # imm = 0x2B8
callq 0x98e0
jmp 0x10359
jmp 0x10335
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x101f9
jmp 0x10345
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x101e8
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x9f50
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::ObtemDirecao(unsigned int, unsigned int, unsigned int, unsigned int, int&, int&)
void Mapa::ObtemDirecao(unsigned int startX, unsigned int startY, unsigned int goalX, unsigned int goalY, int &stepX, int &stepY){
	if(startX >= LARGURA || startY >= ALTURA|| goalX >= LARGURA || goalY >=ALTURA){
		stepX = 0;
		stepY = 0;
		return;
	}

	int u = startX + (startY*LARGURA);
	int v = goalX + (goalY*LARGURA);
	Mapa &mapa = GetMapaGlobal();
	if(mapa._proximo[u][v] >= 0 && (startX != goalX || startY != goalY)){
		stepX = mapa._proximo[u][v] % LARGURA;
		stepY = (mapa._proximo[u][v] - stepX)/LARGURA;

		stepX -= startX;
		stepY -= startY;
	}else{
		stepX = 0;
		stepY = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x20(%rbp)
cmpl $0x15, -0x4(%rbp)
jae 0x103a4
cmpl $0x1b, -0x8(%rbp)
jae 0x103a4
cmpl $0x15, -0xc(%rbp)
jae 0x103a4
cmpl $0x1b, -0x10(%rbp)
jb 0x103bd
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
jmp 0x104a6
movl -0x4(%rbp), %eax
imull $0x15, -0x8(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
imull $0x15, -0x10(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x28(%rbp)
callq 0xf2d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1218, %rax           # imm = 0x1218
movslq -0x24(%rbp), %rcx
imulq $0x8dc, %rcx, %rcx      # imm = 0x8DC
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x10492
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x10414
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x10492
movq -0x30(%rbp), %rax
addq $0x1218, %rax           # imm = 0x1218
movslq -0x24(%rbp), %rcx
imulq $0x8dc, %rcx, %rcx      # imm = 0x8DC
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl $0x15, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rax
movl %edx, (%rax)
movq -0x30(%rbp), %rax
addq $0x1218, %rax           # imm = 0x1218
movslq -0x24(%rbp), %rcx
imulq $0x8dc, %rcx, %rcx      # imm = 0x8DC
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl $0x15, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movl -0x8(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
jmp 0x104a6
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::RemoveElementoMapa(unsigned int, unsigned int)
void Mapa::RemoveElementoMapa(unsigned int x, unsigned int y){
	if(x >= LARGURA || y >=ALTURA) return ;

	Mapa& mapa = GetMapaGlobal();
	if(mapa._mapa[x][y] == Ponto || mapa._mapa[x][y] == Especial)
		mapa._pontosRestantes--;

	mapa._mapa[x][y] = ElementoMapa::Vazio;
	for(unsigned int i=0; i < mapa._objetosMapa.size(); i++){
		Object3D* objMapa = mapa._objetosMapa.at(i);
		if(objMapa->position.x == x && objMapa->position.z == y){
			delete objMapa;
			mapa._objetosMapa.erase(mapa._objetosMapa.begin()+i);
			break;
		}	
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x15, -0x4(%rbp)
jae 0x1053a
cmpl $0x1b, -0x8(%rbp)
jb 0x1053f
jmp 0x106b8
callq 0xf2d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movl -0x4(%rbp), %ecx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
cmpl $0x2, (%rax,%rcx,4)
je 0x1057e
movq -0x10(%rbp), %rax
addq $0x8, %rax
movl -0x4(%rbp), %ecx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
cmpl $0x3, (%rax,%rcx,4)
jne 0x10591
movq -0x10(%rbp), %rax
movl 0x11c0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x11c0(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movl -0x4(%rbp), %ecx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
movl $0x0, (%rax,%rcx,4)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x11c8, %rdi           # imm = 0x11C8
callq 0x11270
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x106b8
movq -0x10(%rbp), %rdi
addq $0x11c8, %rdi           # imm = 0x11C8
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x11290
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movss 0x10(%rax), %xmm0
movl -0x4(%rbp), %eax
cvtsi2ss %rax, %xmm1
ucomiss %xmm1, %xmm0
jne 0x106a8
jp 0x106a8
movq -0x20(%rbp), %rax
movss 0x18(%rax), %xmm0
movl -0x8(%rbp), %eax
cvtsi2ss %rax, %xmm1
ucomiss %xmm1, %xmm0
jne 0x106a8
jp 0x106a8
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x10654
movq -0x50(%rbp), %rdi
callq 0x15e30
movq -0x50(%rbp), %rdi
movl $0x2b8, %esi            # imm = 0x2B8
callq 0x98e0
movq -0x10(%rbp), %rax
addq $0x11c8, %rax           # imm = 0x11C8
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0x11c8, %rdi           # imm = 0x11C8
callq 0x11170
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x11340
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11380
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x112d0
movq %rax, -0x40(%rbp)
jmp 0x106b8
jmp 0x106aa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x105b4
addq $0x60, %rsp
popq %rbp
retq
nop
// File: KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::GetEnemySpawn(unsigned int, Vector2&)
bool Mapa::GetEnemySpawn(unsigned id, Vector2& pos){
	auto it = GetMapaGlobal()._enemySpawn.find(id);
	if(it != GetMapaGlobal()._enemySpawn.end()){
		pos = it->second;
		return true;
	}else{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xf2d0
movq %rax, %rdi
addq $0x11e8, %rdi           # imm = 0x11E8
leaq -0x8(%rbp), %rsi
callq 0x113c0
movq %rax, -0x18(%rbp)
callq 0xf2d0
movq %rax, %rdi
addq $0x11e8, %rdi           # imm = 0x11E8
callq 0x11420
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x113f0
testb $0x1, %al
jne 0x10746
jmp 0x10763
leaq -0x18(%rbp), %rdi
callq 0x11450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x4(%rcx), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x10767
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::OnMenuUpdate()
void Mapa::OnMenuUpdate(){
	tempoInterp += GetFrameTime()*0.0125;
	for(unsigned int i=0; i<_objetosMapa.size(); i++){
		Object3D* objMapa = _objetosMapa.at(i);
		Color col = {(unsigned char)((1+sin(objMapa->position.x/8 + GetTime()*1))*127), 
				  	 (unsigned char)((1+sin(objMapa->position.z/8 + GetTime()*2))*127), 
					 (unsigned char)((1+cos(objMapa->position.x/8 + objMapa->position.z/8 +GetTime()*3))*127)};
		
		objMapa->SetColor(Lerp(objMapa->GetColor(), col, tempoInterp));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3b476
cvtss2sd %xmm0, %xmm0
movsd 0xd7ca3(%rip), %xmm1    # 0xe8888
movsd 0x9472b(%rip), %xmm2    # 0xa5318
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xd7c8b(%rip)    # 0xe8888
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x38(%rbp)
addq $0x11c8, %rdi           # imm = 0x11C8
callq 0x11270
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x10da3
movq -0x30(%rbp), %rdi
addq $0x11c8, %rdi           # imm = 0x11C8
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x11290
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm0
movss 0x946d8(%rip), %xmm1    # 0xa5330
movss %xmm1, -0x5c(%rbp)
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x70(%rbp)
callq 0x3b49c
movsd -0x70(%rbp), %xmm1
addsd %xmm1, %xmm0
callq 0x9170
movss -0x5c(%rbp), %xmm1
movsd 0x944be(%rip), %xmm2    # 0xa5148
movsd %xmm2, -0x50(%rbp)
addsd %xmm2, %xmm0
movsd 0x9468d(%rip), %xmm2    # 0xa5328
movsd %xmm2, -0x48(%rbp)
mulsd %xmm2, %xmm0
cvttsd2si %xmm0, %eax
movb %al, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss 0x18(%rax), %xmm0
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
callq 0x3b49c
movsd -0x68(%rbp), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
callq 0x9170
movss -0x5c(%rbp), %xmm2
movsd -0x50(%rbp), %xmm3
movsd -0x48(%rbp), %xmm1
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, -0x1b(%rbp)
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm0
movss 0x18(%rax), %xmm1
mulss %xmm2, %xmm0
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
callq 0x3b49c
movsd -0x58(%rbp), %xmm1
movsd 0x9443d(%rip), %xmm2    # 0xa5168
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x9ff0
movsd -0x50(%rbp), %xmm2
movsd -0x48(%rbp), %xmm1
addsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, -0x1a(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x160c0
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movsd 0xd7b11(%rip), %xmm0    # 0xe8888
cvtsd2ss %xmm0, %xmm0
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0xb780
movq -0x40(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x16050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10c04
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: KellerMartins[P]PDS2-Pacman/source/game/pacman.cpp
// Function: Pacman::Morrer()
void Pacman::Morrer(){
	_vivo = false;
	if(_vidas>0)
		_vidas--;
	
	_timerAnimacao = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, 0x2c0(%rax)
cmpl $0x0, 0x2c4(%rax)
jbe 0x13ef3
movq -0x10(%rbp), %rax
movl 0x2c4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c4(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x2e0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/game/pacman.cpp
// Function: Pacman::Resetar()
void Pacman::Resetar(){
	_pontuacao = 0;
	_vivo = true;
	_vidas = 3;
	_velocidade = PACMAN_SPEED_DEFAULT;
	_timerAnimacao = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c8(%rax)
movb $0x1, 0x2c0(%rax)
movl $0x3, 0x2c4(%rax)
movss 0x911f9(%rip), %xmm0    # 0xa53f8
movss %xmm0, 0x2dc(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x2e0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/game/pacman.cpp
// Function: Pacman::OnRestart()
void Pacman::OnRestart(){
	Vector2 spawn = Mapa::GetPlayerSpawn();
	_modelo.position = {spawn.x, 0, spawn.y};
	_x = spawn.x;
	_y = spawn.y;
	_direcaoY = 0;
	_direcaoX = 0;
	_vivo = true;
	_parado.SetTimer(0);
	_modelo.Load3DModel(_parado.GetCurrentFrame());
	Enemy::IsOver(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x106c0
movq -0x70(%rbp), %rdi
movlpd %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
movl -0x14(%rbp), %eax
movl %eax, 0x20(%rdi)
movq -0x1c(%rbp), %rax
movq %rax, 0x18(%rdi)
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x2d4(%rdi)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x2d8(%rdi)
movl $0x0, 0x2cc(%rdi)
movl $0x0, 0x2d0(%rdi)
movb $0x1, 0x2c0(%rdi)
addq $0x320, %rdi            # imm = 0x320
movq %rdi, -0x68(%rbp)
xorps %xmm0, %xmm0
callq 0x14b20
movq -0x68(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x14ba0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x15e90
jmp 0x1474e
leaq -0x40(%rbp), %rdi
callq 0x9530
xorl %edi, %edi
callq 0xc440
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9530
movq -0x48(%rbp), %rdi
callq 0x9f50
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/graphics/animation.cpp
// Function: Animation::Animation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, bool)
Animation::Animation(std::string basePath, unsigned frameCount, bool loop){
    _basePath = basePath;
    _frameCount = frameCount;
    _timer = 0;
    _loop = loop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x9b50
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9070
jmp 0x14991
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x20(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rax)
movb -0x15(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x28(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9530
movq -0x20(%rbp), %rdi
callq 0x9f50
// File: KellerMartins[P]PDS2-Pacman/source/graphics/animation.cpp
// Function: Animation::Preload()
void Animation::Preload(){
    for(unsigned i=0; i<_frameCount; i++){
        std::ostringstream stream;
        stream << _basePath << "_" << i << ".obj";
        Object3D::Cache3DModel(stream.str());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x1c0(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x20(%rcx), %eax
jae 0x14b05
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x9b10
movq -0x1d0(%rbp), %rdi
movq -0x1c0(%rbp), %rsi
callq 0x97a0
movq %rax, -0x1c8(%rbp)
jmp 0x14a33
movq -0x1c8(%rbp), %rdi
leaq 0x90a93(%rip), %rsi     # 0xa54d4
callq 0x9890
movq %rax, -0x1d8(%rbp)
jmp 0x14a4f
movq -0x1d8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x9af0
movq %rax, -0x1e0(%rbp)
jmp 0x14a67
movq -0x1e0(%rbp), %rdi
leaq 0x909e2(%rip), %rsi     # 0xa5457
callq 0x9890
jmp 0x14a7c
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x9900
jmp 0x14a91
leaq -0x1b8(%rbp), %rdi
callq 0x15fa0
jmp 0x14a9f
leaq -0x1b8(%rbp), %rdi
callq 0x9530
leaq -0x188(%rbp), %rdi
callq 0x91c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x149f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x14af7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x9530
leaq -0x188(%rbp), %rdi
callq 0x91c0
jmp 0x14b0e
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x9f50
nopw (%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/graphics/animation.cpp
// Function: Animation::SetTimer(float)
void Animation::SetTimer(float time){
    if(!_loop && time > _frameCount-1){
        _timer = _frameCount-1;
    }else{
        _timer = fModulus(time,_frameCount);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x28(%rax)
jne 0x14b6c
movq -0x18(%rbp), %rax
movss -0xc(%rbp), %xmm0
movl 0x20(%rax), %eax
decl %eax
cvtsi2ss %rax, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x14b6c
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
decl %ecx
cvtsi2ss %rcx, %xmm0
movss %xmm0, 0x24(%rax)
jmp 0x14b8b
movq -0x18(%rbp), %rax
movss -0xc(%rbp), %xmm0
movl 0x20(%rax), %eax
cvtsi2ss %rax, %xmm1
callq 0xba10
movq -0x18(%rbp), %rax
movss %xmm0, 0x24(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/graphics/animation.cpp
// Function: Animation::GetCurrentFrame[abi:cxx11]()
std::string Animation::GetCurrentFrame(){
    int frame = (int)_timer;
    std::ostringstream stream;
    stream << _basePath << "_" << frame << ".obj";
    return stream.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
cvttss2si 0x24(%rax), %eax
movl %eax, -0x14(%rbp)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x9b10
movq -0x1b8(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
callq 0x97a0
movq %rax, -0x1a8(%rbp)
jmp 0x14c06
movq -0x1a8(%rbp), %rdi
leaq 0x908c0(%rip), %rsi     # 0xa54d4
callq 0x9890
movq %rax, -0x1d0(%rbp)
jmp 0x14c22
movq -0x1d0(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9f00
movq %rax, -0x1d8(%rbp)
jmp 0x14c3a
movq -0x1d8(%rbp), %rdi
leaq 0x9080f(%rip), %rsi     # 0xa5457
callq 0x9890
jmp 0x14c4f
movq -0x1c8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x9900
jmp 0x14c64
leaq -0x190(%rbp), %rdi
callq 0x91c0
movq -0x1c0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x91c0
movq -0x198(%rbp), %rdi
callq 0x9f50
nopw (%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/graphics/debugPrimitives.cpp
// Function: RenderManager::RenderDebugPrimitives(Camera3D&)
void RenderDebugPrimitives(Camera &camera){
        #ifndef NDEBUG
        BeginMode3D(camera);  
            for(DebugPrimitive* p : _debugPrimitivesToRender){
                p->Draw();
                delete p;
            }  
        EndMode3D();

        _debugPrimitivesToRender.clear();
        #endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x2c, %edx
callq 0x96e0
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups -0x1c(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x1c(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x3a19c
leaq 0x2110c9(%rip), %rax    # 0x226100
movq %rax, -0x40(%rbp)
leaq 0x2110be(%rip), %rdi    # 0x226100
callq 0x152e0
movq %rax, -0x48(%rbp)
leaq 0x2110ae(%rip), %rdi    # 0x226100
callq 0x15310
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x15340
testb $0x1, %al
jne 0x1506e
jmp 0x150ac
leaq -0x48(%rbp), %rdi
callq 0x15370
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x1509f
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x150a1
leaq -0x48(%rbp), %rdi
callq 0x15390
jmp 0x1505b
callq 0x3a498
leaq 0x211048(%rip), %rdi    # 0x226100
callq 0x153b0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/graphics/object3D.cpp
// Function: Object3D::Object3D()
Object3D::Object3D(){
    _hasModel = false;
    _color = RAYWHITE;
    shouldRender = false;
    position = VECTOR3_ZERO;
    scale = (Vector3){1,1,1};
    rotationAxis = (Vector3){0,1,0};
    rotationAngle = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x16120
movq -0x38(%rbp), %rax
movb $0x0, 0x8(%rax)
movb $-0xb, -0xc(%rbp)
movb $-0xb, -0xb(%rbp)
movb $-0xb, -0xa(%rbp)
movb $-0x1, -0x9(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x9(%rax)
movb $0x0, 0xd(%rax)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x18(%rax)
movss 0x8f357(%rip), %xmm0    # 0xa5010
movss %xmm0, -0x24(%rbp)
movss 0x8f34a(%rip), %xmm0    # 0xa5010
movss %xmm0, -0x20(%rbp)
movss 0x8f33d(%rip), %xmm0    # 0xa5010
movss %xmm0, -0x1c(%rbp)
movq -0x24(%rbp), %rcx
movq %rcx, 0x1c(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x24(%rax)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movss 0x8f31a(%rip), %xmm0    # 0xa5010
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0x30(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x34(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: KellerMartins[P]PDS2-Pacman/source/graphics/object3D.cpp
// Function: Object3D::Load3DModel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Object3D::Load3DModel(const std::string modelPath){
    if(!_hasModel){
        _objectID = RenderManager::RegisterObjectToRender((Object3D*)this);
    }
    _hasModel = true;
    shouldRender = true;

    //Insert the loaded model inside the cache when loading it for the first time
    auto modelIt = _modelsCache.find(modelPath);
    if(modelIt == _modelsCache.end()){
        Cache3DModel(modelPath);
    }
    
    _modelsCache[modelPath].material.maps[MAP_DIFFUSE].color = _color;
    model = _modelsCache[modelPath];
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, 0x8(%rax)
jne 0x15ecd
movq -0x60(%rbp), %rdi
callq 0x18800
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rax
movb $0x1, 0x8(%rax)
movb $0x1, 0xd(%rax)
leaq 0x21023c(%rip), %rdi    # 0x226120
callq 0x16140
movq %rax, -0x20(%rbp)
leaq 0x21022c(%rip), %rdi    # 0x226120
callq 0x161a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x16170
testb $0x1, %al
jne 0x15f10
jmp 0x15f4e
movq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x93b0
movq -0x70(%rbp), %rdi
callq 0x15fa0
jmp 0x15f2c
leaq -0x48(%rbp), %rdi
callq 0x9530
jmp 0x15f4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9530
jmp 0x15f96
movq -0x68(%rbp), %rsi
leaq 0x2101c7(%rip), %rdi    # 0x226120
callq 0x161d0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rcx
movl 0x9(%rcx), %ecx
movl %ecx, 0x138(%rax)
leaq 0x2101aa(%rip), %rdi    # 0x226120
callq 0x161d0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
addq $0x38, %rdi
movl $0x280, %edx            # imm = 0x280
callq 0x96e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x9f50
nop
// File: KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::LoadShaders()
void LoadShaders(){
        _outlineFilter = LoadShader("assets/shaders/fxBase.vs","assets/shaders/outlineFilter.fs");
        _blurPass = LoadShader("assets/shaders/fxBase.vs","assets/shaders/blurPass.fs");
        _screenShader = LoadShader("assets/shaders/fxBase.vs","assets/shaders/screen.fs");
        _copyRTShader = LoadShader("assets/shaders/fxBase.vs","assets/shaders/copyRT.fs");

        _maskShader = LoadShader("assets/shaders/modelVert.vs","assets/shaders/maskFrag.fs");
        _colorShader = LoadShader("assets/shaders/modelVert.vs","assets/shaders/colorFrag.fs");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
leaq -0x84(%rbp), %rdi
leaq 0x8dcc9(%rip), %rsi     # 0xa5572
leaq 0x8dcdb(%rip), %rdx     # 0xa558b
callq 0x2df80
leaq 0x20ea40(%rip), %rdi    # 0x2262fc
leaq -0x84(%rbp), %rsi
movl $0x84, %edx
callq 0x96e0
leaq -0x108(%rbp), %rdi
leaq 0x8dc97(%rip), %rsi     # 0xa5572
leaq 0x8dcc9(%rip), %rdx     # 0xa55ab
callq 0x2df80
leaq 0x20e882(%rip), %rdi    # 0x226170
leaq -0x108(%rbp), %rsi
movl $0x84, %edx
callq 0x96e0
leaq -0x18c(%rbp), %rdi
leaq 0x8dc65(%rip), %rsi     # 0xa5572
leaq 0x8dcb2(%rip), %rdx     # 0xa55c6
callq 0x2df80
leaq 0x20ea60(%rip), %rdi    # 0x226380
leaq -0x18c(%rbp), %rsi
movl $0x84, %edx
callq 0x96e0
leaq -0x210(%rbp), %rdi
leaq 0x8dc33(%rip), %rsi     # 0xa5572
leaq 0x8dc99(%rip), %rdx     # 0xa55df
callq 0x2df80
leaq 0x20eab2(%rip), %rdi    # 0x226404
leaq -0x210(%rbp), %rsi
movl $0x84, %edx
callq 0x96e0
leaq -0x294(%rbp), %rdi
leaq 0x8dc87(%rip), %rsi     # 0xa55f8
leaq 0x8dc9c(%rip), %rdx     # 0xa5614
callq 0x2df80
leaq 0x20e870(%rip), %rdi    # 0x2261f4
leaq -0x294(%rbp), %rsi
movl $0x84, %edx
callq 0x96e0
leaq -0x318(%rbp), %rdi
leaq 0x8dc55(%rip), %rsi     # 0xa55f8
leaq 0x8dc85(%rip), %rdx     # 0xa562f
callq 0x2df80
leaq 0x20e8c2(%rip), %rdi    # 0x226278
leaq -0x318(%rbp), %rsi
movl $0x84, %edx
callq 0x96e0
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
// File: KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::SetBloomQuality(RenderManager::BlurQuality)
void SetBloomQuality(BlurQuality quality){
        switch(quality){
            case Low:
                _blurDownscale = 3;
                _blurQuality = 0;
            break;

            case Medium:
                _blurDownscale = 2;
                _blurQuality = 1;
            break;

            case High:
                _blurDownscale = 1;
                _blurQuality = 2;
            break;
        }
        

        if(_isInitialized){
            UnloadRenderTexture(_blurRT);
            UnloadRenderTexture(_vBlurRT);
        }
        _blurRT = LoadRenderTexture(_screenWidth/(_blurDownscale), _screenHeight/(_blurDownscale));
        _vBlurRT = LoadRenderTexture(_screenWidth/(_blurDownscale), _screenHeight/(_blurDownscale));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xbc(%rbp)
testl %eax, %eax
je 0x17f57
jmp 0x17f3d
movl -0xbc(%rbp), %eax
subl $0x1, %eax
je 0x17f6d
jmp 0x17f4a
movl -0xbc(%rbp), %eax
subl $0x2, %eax
je 0x17f83
jmp 0x17f97
movl $0x3, 0xd095b(%rip)     # 0xe88bc
movl $0x0, 0x20e201(%rip)    # 0x22616c
jmp 0x17f97
movl $0x2, 0xd0945(%rip)     # 0xe88bc
movl $0x1, 0x20e1eb(%rip)    # 0x22616c
jmp 0x17f97
movl $0x1, 0xd092f(%rip)     # 0xe88bc
movl $0x2, 0x20e1d5(%rip)    # 0x22616c
testb $0x1, 0x20e1c2(%rip)    # 0x226160
je 0x18008
leaq -0x30(%rbp), %rdi
leaq 0x20e541(%rip), %rsi    # 0x2264ec
movl $0x2c, %edx
callq 0x96e0
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups -0x14(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x1c(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x7bdae
leaq -0x60(%rbp), %rdi
leaq 0x20e539(%rip), %rsi    # 0x226518
movl $0x2c, %edx
callq 0x96e0
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups -0x44(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x1c(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x7bdae
movl 0x20e156(%rip), %eax    # 0x226164
cltd
idivl 0xd08a7(%rip)           # 0xe88bc
movl %eax, %esi
movl 0x20e14b(%rip), %eax    # 0x226168
cltd
idivl 0xd0898(%rip)           # 0xe88bc
movl %eax, %edx
leaq -0x8c(%rbp), %rdi
callq 0x7bd04
leaq 0x20e4b3(%rip), %rdi    # 0x2264ec
leaq -0x8c(%rbp), %rsi
movl $0x2c, %edx
callq 0x96e0
movl 0x20e114(%rip), %eax    # 0x226164
cltd
idivl 0xd0865(%rip)           # 0xe88bc
movl %eax, %esi
movl 0x20e109(%rip), %eax    # 0x226168
cltd
idivl 0xd0856(%rip)           # 0xe88bc
movl %eax, %edx
leaq -0xb8(%rbp), %rdi
callq 0x7bd04
leaq 0x20e49d(%rip), %rdi    # 0x226518
leaq -0xb8(%rbp), %rsi
movl $0x2c, %edx
callq 0x96e0
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::ReloadShaders()
void ReloadShaders(){

        //Unload old shaders
        if(_isInitialized){
            UnloadShader(_outlineFilter);
            UnloadShader(_maskShader);
            UnloadShader(_colorShader);
            UnloadShader(_blurPass);
            UnloadShader(_screenShader);
            UnloadShader(_copyRTShader);
        }

        LoadShaders();
        SetShaderUniforms();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3c0, %rsp            # imm = 0x3C0
testb $0x1, 0x20db1e(%rip)    # 0x226160
je 0x187b9
leaq -0x88(%rbp), %rdi
leaq 0x20dca6(%rip), %rsi    # 0x2262fc
movl $0x84, %edx
callq 0x96e0
movq %rsp, %rax
movl $0x10, %ecx
leaq -0x88(%rbp), %rsi
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x80(%rax)
callq 0x2e4a1
leaq -0x110(%rbp), %rdi
leaq 0x20db63(%rip), %rsi    # 0x2261f4
movl $0x84, %edx
callq 0x96e0
movq %rsp, %rax
movl $0x10, %ecx
leaq -0x110(%rbp), %rsi
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl -0x90(%rbp), %ecx
movl %ecx, 0x80(%rax)
callq 0x2e4a1
leaq -0x198(%rbp), %rdi
leaq 0x20dba9(%rip), %rsi    # 0x226278
movl $0x84, %edx
callq 0x96e0
movq %rsp, %rax
movl $0x10, %ecx
leaq -0x198(%rbp), %rsi
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl -0x118(%rbp), %ecx
movl %ecx, 0x80(%rax)
callq 0x2e4a1
leaq -0x220(%rbp), %rdi
leaq 0x20da63(%rip), %rsi    # 0x226170
movl $0x84, %edx
callq 0x96e0
movq %rsp, %rax
movl $0x10, %ecx
leaq -0x220(%rbp), %rsi
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl -0x1a0(%rbp), %ecx
movl %ecx, 0x80(%rax)
callq 0x2e4a1
leaq -0x2a8(%rbp), %rdi
leaq 0x20dc35(%rip), %rsi    # 0x226380
movl $0x84, %edx
callq 0x96e0
movq %rsp, %rax
movl $0x10, %ecx
leaq -0x2a8(%rbp), %rsi
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl -0x228(%rbp), %ecx
movl %ecx, 0x80(%rax)
callq 0x2e4a1
leaq -0x330(%rbp), %rdi
leaq 0x20dc7b(%rip), %rsi    # 0x226404
movl $0x84, %edx
callq 0x96e0
movq %rsp, %rax
movl $0x10, %ecx
leaq -0x330(%rbp), %rsi
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl -0x2b0(%rbp), %ecx
movl %ecx, 0x80(%rax)
callq 0x2e4a1
callq 0x17890
callq 0x180a0
addq $0x3c0, %rsp            # imm = 0x3C0
popq %rbp
retq
nopl (%rax)
// File: KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::CameraFollow(Vector3, float)
void CameraFollow(Vector3 position, float speed){
        Vector3 newPos =  (Vector3){position.x + _cameraOffset.x, 
                                    position.y + _cameraOffset.y,
                                    position.z + _cameraOffset.z};
        camera.position = Lerp(camera.position, newPos, GetFrameTime() * speed);
        camera.target = Lerp(camera.target, position, GetFrameTime() * speed);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movlpd %xmm0, -0x20(%rbp)
movss %xmm1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movss %xmm2, -0x24(%rbp)
movss -0x10(%rbp), %xmm0
movss 0x20d84f(%rip), %xmm1   # 0x226154
addss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0xc(%rbp), %xmm0
movss 0x20d83d(%rip), %xmm1   # 0x226158
addss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x8(%rbp), %xmm0
movss 0x20d82b(%rip), %xmm1   # 0x22615c
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movl 0xcff58(%rip), %eax     # 0xe8898
movl %eax, -0x48(%rbp)
movq 0xcff46(%rip), %rax     # 0xe8890
movq %rax, -0x50(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x3b476
movaps %xmm0, %xmm4
movss -0x24(%rbp), %xmm0
mulss %xmm0, %xmm4
movl -0x48(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
movsd -0x70(%rbp), %xmm0
movss -0x68(%rbp), %xmm1
movl -0x58(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
movsd -0x80(%rbp), %xmm2
movss -0x78(%rbp), %xmm3
callq 0xb6b0
movss %xmm1, -0x88(%rbp)
movlpd %xmm0, -0x90(%rbp)
movl -0x88(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, 0xcfec9(%rip)     # 0xe8898
movq -0x40(%rbp), %rax
movq %rax, 0xcfeb6(%rip)     # 0xe8890
movl 0xcfec4(%rip), %eax     # 0xe88a4
movl %eax, -0xa0(%rbp)
movq 0xcfeaf(%rip), %rax     # 0xe889c
movq %rax, -0xa8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x3b476
movaps %xmm0, %xmm4
movss -0x24(%rbp), %xmm0
mulss %xmm0, %xmm4
movl -0xa0(%rbp), %eax
movl %eax, -0xc0(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movsd -0xc8(%rbp), %xmm0
movss -0xc0(%rbp), %xmm1
movl -0xb0(%rbp), %eax
movl %eax, -0xd0(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movsd -0xd8(%rbp), %xmm2
movss -0xd0(%rbp), %xmm3
callq 0xb6b0
movss %xmm1, -0xe0(%rbp)
movlpd %xmm0, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0x9c(%rbp)
movl -0xe0(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x9c(%rbp), %rax
movq %rax, 0xcfdf2(%rip)     # 0xe889c
movl -0x94(%rbp), %eax
movl %eax, 0xcfdee(%rip)     # 0xe88a4
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::Render()
void Render(){
        UpdateCamera(&camera);
        if(!_isInitialized) return;
        
        BeginDrawing();
            ClearBackground(BLACK);

            glDisable(GL_BLEND);
            RenderBaseEffect();
            RenderBloom();
            RenderFinalComposition();

            glEnable(GL_BLEND);
            UI::Render();

            RenderDebugPrimitives(camera);

            #ifndef NDEBUG
            DrawFPS(0,0);
            #endif

        EndDrawing();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xcfd61(%rip), %rdi     # 0xe8890
callq 0x35a75
testb $0x1, 0x20d625(%rip)    # 0x226160
jne 0x18b3f
jmp 0x18ba6
callq 0x39a9a
movb $0x0, -0x4(%rbp)
movb $0x0, -0x3(%rbp)
movb $0x0, -0x2(%rbp)
movb $-0x1, -0x1(%rbp)
movl -0x4(%rbp), %edi
callq 0x39a65
movl $0xbe2, %edi            # imm = 0xBE2
leaq 0x230990(%rip), %rax    # 0x2494f8
callq *(%rax)
callq 0x18bb0
callq 0x193d0
callq 0x19a00
movl $0xbe2, %edi            # imm = 0xBE2
leaq 0x230bc3(%rip), %rax    # 0x249748
callq *(%rax)
callq 0x1a8d0
leaq 0xcfcfd(%rip), %rdi     # 0xe8890
callq 0x14ff0
xorl %esi, %esi
movl %esi, %edi
callq 0x69955
callq 0x39b62
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::RenderFinalComposition()
void RenderFinalComposition(){
        BeginShaderMode(_screenShader);
            glActiveTexture(GL_TEXTURE1);
            glBindTexture(GL_TEXTURE_2D, _blurRT.texture.id);
            DrawTexturePro(_baseRT.texture, (Rectangle){ 0, 0, (float)_screenWidth, (float)-_screenHeight }, 
                                            (Rectangle){ 0, 0, (float)_screenWidth, (float)_screenHeight }, (Vector2){ 0, 0 }, 0,  WHITE);
        EndShaderMode();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
leaq 0x20c96e(%rip), %rsi    # 0x226380
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movl $0x84, %edx
callq 0x96e0
movq -0xd8(%rbp), %rsi
movq %rsp, %rax
movl $0x10, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x80(%rax)
callq 0x2e4d3
leaq 0x22f67c(%rip), %rax    # 0x2490d0
movq (%rax), %rax
movl $0x84c1, %edi           # imm = 0x84C1
callq *%rax
leaq 0x22f25b(%rip), %rax    # 0x248cc0
movq (%rax), %rax
movl 0x20ca82(%rip), %esi    # 0x2264f0
movl $0xde1, %edi            # imm = 0xDE1
callq *%rax
movl 0x20ca2d(%rip), %eax    # 0x2264a8
movl %eax, -0x90(%rbp)
movups 0x20ca10(%rip), %xmm0   # 0x226498
movaps %xmm0, -0xa0(%rbp)
movl $0x0, -0xb0(%rbp)
movl $0x0, -0xac(%rbp)
cvtsi2ssl 0x20c6b9(%rip), %xmm0 # 0x226164
movss %xmm0, -0xa8(%rbp)
movl 0x20c6af(%rip), %eax    # 0x226168
negl %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0xa4(%rbp)
movl $0x0, -0xc0(%rbp)
movl $0x0, -0xbc(%rbp)
cvtsi2ssl 0x20c681(%rip), %xmm0 # 0x226164
movss %xmm0, -0xb8(%rbp)
cvtsi2ssl 0x20c675(%rip), %xmm0 # 0x226168
movss %xmm0, -0xb4(%rbp)
movl $0x0, -0xc8(%rbp)
movl $0x0, -0xc4(%rbp)
movb $-0x1, -0xcc(%rbp)
movb $-0x1, -0xcb(%rbp)
movb $-0x1, -0xca(%rbp)
movb $-0x1, -0xc9(%rbp)
movsd -0xb0(%rbp), %xmm0
movsd -0xa8(%rbp), %xmm1
movsd -0xc0(%rbp), %xmm2
movsd -0xb8(%rbp), %xmm3
movsd -0xc8(%rbp), %xmm4
movl -0xcc(%rbp), %edi
movl -0x90(%rbp), %ecx
movq %rsp, %rax
movl %ecx, 0x10(%rax)
movups -0xa0(%rbp), %xmm5
movups %xmm5, (%rax)
xorps %xmm5, %xmm5
callq 0x835b3
callq 0x2e516
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UI::GetImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Texture2D& GetImage(std::string path){
        auto imageIt = _images.find(path);
        if(imageIt == _images.end()){
            Texture2D& imageTex = _images[path];

            imageTex = LoadTexture(path.c_str());
            SetTextureFilter(imageTex, FILTER_TRILINEAR);
            GenTextureMipmaps(&imageTex);
        }

        return _images[path];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, %rsi
movq %rsi, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x20c1fe(%rip), %rdi    # 0x2265d8
callq 0x1aef0
movq %rax, -0x10(%rbp)
leaq 0x20c1ee(%rip), %rdi    # 0x2265d8
callq 0x1af50
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1af20
testb $0x1, %al
jne 0x1a409
jmp 0x1a492
movq -0x50(%rbp), %rsi
leaq 0x20c1c4(%rip), %rdi    # 0x2265d8
callq 0x1af80
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x9360
movq %rax, %rsi
leaq -0x34(%rbp), %rdi
callq 0x7bbcd
movq -0x20(%rbp), %rax
movq -0x34(%rbp), %rcx
movq %rcx, (%rax)
movq -0x2c(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x40(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x38(%rbp)
leaq -0x48(%rbp), %rax
movl $0x2, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x830eb
movq -0x20(%rbp), %rdi
callq 0x830d1
movq -0x50(%rbp), %rsi
leaq 0x20c13b(%rip), %rdi    # 0x2265d8
callq 0x1af80
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UI::SetFont(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SetFont(std::string fontPath){
        if(_loadedFont)
            UnloadFont(_font);
        
        _loadedFont = true;
        _font = LoadFont(fontPath.c_str());
        SetTextureFilter(_font.texture, FILTER_TRILINEAR);
        GenTextureMipmaps(&_font.texture);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
testb $0x1, 0x20c0ee(%rip)    # 0x2265b8
je 0x1a500
leaq -0x30(%rbp), %rdi
leaq 0x20c0b9(%rip), %rsi    # 0x226590
movl $0x28, %edx
callq 0x96e0
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x68f2d
movq -0x78(%rbp), %rdi
movb $0x1, 0x20c0ad(%rip)    # 0x2265b8
callq 0x9360
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x67bc5
leaq 0x20c06d(%rip), %rdi    # 0x226590
leaq -0x58(%rbp), %rsi
movl $0x28, %edx
callq 0x96e0
movq 0x20c058(%rip), %rax    # 0x226590
movq %rax, -0x70(%rbp)
movq 0x20c055(%rip), %rax    # 0x226598
movq %rax, -0x68(%rbp)
movl 0x20c053(%rip), %eax    # 0x2265a0
movl %eax, -0x60(%rbp)
leaq -0x70(%rbp), %rax
movl $0x2, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x830eb
leaq 0x20c014(%rip), %rdi    # 0x226590
callq 0x830d1
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)