LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x8(%rdi), %rbx
addq $0x11c8, %rdi           # imm = 0x11C8
movq %rdi, -0x48(%rbp)
xorl %eax, %eax
leaq 0xcd6bb(%rip), %r13     # 0xd8ec0
leaq 0x8cc92(%rip), %r15     # 0x9849e
cmpq $0x1b, %rax
je 0xb8dc
movq %rax, -0x38(%rbp)
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
movq %rbx, -0x40(%rbp)
xorl %r14d, %r14d
cmpq $0x15, %r14
je 0xb8c8
movslq (%rbx), %r12
cmpq $0x3, %r12
jg 0xb8bc
shlq $0x5, %r12
addq %r13, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xc612
testb %al, %al
je 0xb8bc
movl $0x2b8, %edi            # imm = 0x2B8
callq 0x8860
movq %rax, %r13
leaq -0x70(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x8ad0
movq %r13, %rdi
movq %r15, %rsi
movl $0xfff17900, %edx       # imm = 0xFFF17900
callq 0xdbf6
movq %r15, %rdi
callq 0x83a0
cvtsi2ss %r14d, %xmm0
movq %r13, -0x50(%rbp)
movss %xmm0, 0x10(%r13)
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x18(%r13)
movq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xc5ee
leaq 0xcd60b(%rip), %r13     # 0xd8ec0
leaq 0x8cbe2(%rip), %r15     # 0x9849e
incq %r14
addq $0x6c, %rbx
jmp 0xb82a
movq -0x38(%rbp), %rax
incq %rax
movq -0x40(%rbp), %rbx
addq $0x4, %rbx
jmp 0xb80c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x83a0
jmp 0xb8fc
movq %rax, %rbx
movl $0x2b8, %esi            # imm = 0x2B8
movq %r13, %rdi
callq 0x8890
movq %rbx, %rdi
callq 0x8ed0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
callq 0xb43c
leaq 0xcd247(%rip), %r14     # 0xd8f48
xorl %eax, %eax
leaq -0x68(%rbp), %rbx
cmpq $0x1b, %rax
je 0xbdd4
movq %rax, -0x38(%rbp)
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
movq %r14, -0x40(%rbp)
xorl %r15d, %r15d
cmpq $0x15, %r15
je 0xbdc0
movl 0x8dc(%r14), %r13d
movl %r13d, (%r14)
movl %r13d, %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0xbdb4
incl 0xce3b6(%rip)           # 0xda100
movl $0x2b8, %edi            # imm = 0x2B8
callq 0x8860
movq %rax, %r12
shlq $0x5, %r13
leaq 0xcd15e(%rip), %rax     # 0xd8ec0
addq %rax, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8ad0
movq %r12, %rdi
movq %rbx, %rsi
movl $0xfff17900, %edx       # imm = 0xFFF17900
callq 0xdbf6
movq %rbx, %rdi
callq 0x83a0
cvtsi2ss %r15d, %xmm0
movq %r12, -0x48(%rbp)
movss %xmm0, 0x10(%r12)
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x18(%r12)
leaq 0xce35d(%rip), %rdi     # 0xda108
leaq -0x48(%rbp), %rsi
callq 0xc5ee
incq %r15
addq $0x6c, %r14
jmp 0xbd25
movq -0x38(%rbp), %rax
incq %rax
movq -0x40(%rbp), %r14
addq $0x4, %r14
jmp 0xbd07
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xbdf4
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x83a0
movl $0x2b8, %esi            # imm = 0x2B8
movq %r12, %rdi
callq 0x8890
movq %rbx, %rdi
callq 0x8ed0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
cmpl $0x15, %edi
setb %al
cmpl $0x1b, %esi
setb %cl
andb %al, %cl
cmpl $0x15, %edx
setb %al
andb %cl, %al
cmpl $0x1b, %r13d
setb %cl
testb %cl, %al
jne 0xbe4a
andl $0x0, (%r8)
xorl %eax, %eax
jmp 0xbed7
movl %edx, %ebx
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
imull $0x15, %esi, %r15d
addl %edi, %r15d
imull $0x15, %r13d, %r14d
addl %edx, %r14d
movl %esi, -0x2c(%rbp)
movl %edi, %r12d
callq 0xb43c
movl -0x2c(%rbp), %r8d
imulq $0x8dc, %r15, %rax      # imm = 0x8DC
leaq 0xcd0c1(%rip), %rcx     # 0xd8f40
addq %rax, %rcx
movl 0x1218(%rcx,%r14,4), %eax
testl %eax, %eax
js 0xbe99
xorl %r12d, %ebx
xorl %r8d, %r13d
orl %ebx, %r13d
jne 0xbea8
movq -0x38(%rbp), %rax
andl $0x0, (%rax)
xorl %eax, %eax
movq -0x40(%rbp), %r9
jmp 0xbed7
leaq (%rcx,%r14,4), %rcx
addq $0x1218, %rcx           # imm = 0x1218
pushq $0x15
popq %rsi
xorl %edx, %edx
divl %esi
movq -0x38(%rbp), %rdi
movl %edx, (%rdi)
movl (%rcx), %eax
subl %edx, %eax
cltd
idivl %esi
movq -0x40(%rbp), %r9
movl %eax, (%r9)
subl %r12d, (%rdi)
movl (%r9), %eax
subl %r8d, %eax
movl %eax, (%r9)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x15, %edi
setae %al
cmpl $0x1b, %esi
setae %cl
orb %al, %cl
je 0xbf61
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %ebx
movl %edi, %r14d
callq 0xb43c
movl %r14d, %eax
movl %ebx, %ecx
imulq $0x6c, %rax, %rax
leaq 0xccfc5(%rip), %rdx     # 0xd8f40
addq %rax, %rdx
leaq (%rdx,%rcx,4), %rax
addq $0x8, %rax
movl (%rax), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0xbf96
decl 0xce16a(%rip)           # 0xda100
andl $0x0, (%rax)
cvtsi2ss %r14d, %xmm0
movss %xmm0, -0x20(%rbp)
cvtsi2ss %ebx, %xmm0
movss %xmm0, -0x1c(%rbp)
xorl %ebx, %ebx
leaq 0xce153(%rip), %r14     # 0xda108
movl %ebx, %ebx
movq 0xce152(%rip), %rax     # 0xda110
subq 0xce143(%rip), %rax     # 0xda108
sarq $0x3, %rax
cmpq %rbx, %rax
jbe 0xbf56
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc620
movq (%rax), %r15
movss 0x10(%r15), %xmm0
ucomiss -0x20(%rbp), %xmm0
jne 0xbff8
jp 0xbff8
movss 0x18(%r15), %xmm0
ucomiss -0x1c(%rbp), %xmm0
jne 0xbff8
jnp 0xbffc
incl %ebx
jmp 0xbfb5
movq %r15, %rdi
callq 0xdcbe
movl $0x2b8, %esi            # imm = 0x2B8
movq %r15, %rdi
callq 0x8890
leaq 0xce0f0(%rip), %rdi     # 0xda108
shlq $0x3, %rbx
addq 0xce0e5(%rip), %rbx     # 0xda108
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc642
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq -0x14(%rbp), %r14
movl %edi, (%r14)
callq 0xb43c
leaq 0xce0bd(%rip), %rdi     # 0xda128
movq %r14, %rsi
callq 0xcb52
movq %rax, %r14
callq 0xb43c
leaq 0xce0ae(%rip), %rax     # 0xda130
cmpq %rax, %r14
je 0xc08e
movq 0x24(%r14), %rcx
movq %rcx, (%rbx)
cmpq %rax, %r14
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x2e7fe
cvtss2sd %xmm0, %xmm0
mulsd 0x8c0af(%rip), %xmm0    # 0x98418
addsd 0xca4d7(%rip), %xmm0    # 0xd6848
movsd %xmm0, 0xca4cf(%rip)    # 0xd6848
movq %rbx, -0x40(%rbp)
leaq 0x11c8(%rbx), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movl %eax, %r15d
movq -0x40(%rbp), %rcx
movq 0x11d0(%rcx), %rax
subq 0x11c8(%rcx), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0xc4e0
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0xc620
movq (%rax), %r12
movss 0x10(%r12), %xmm0
movss 0x8c076(%rip), %xmm1    # 0x98440
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x2e824
addsd -0x30(%rbp), %xmm0
callq 0x8150
movsd 0x8c03a(%rip), %xmm1    # 0x98428
addsd %xmm1, %xmm0
movsd 0x8c03e(%rip), %xmm1    # 0x98438
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %r13d
movss 0x18(%r12), %xmm0
mulss 0x8c02e(%rip), %xmm0    # 0x98440
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x2e824
addsd %xmm0, %xmm0
addsd -0x30(%rbp), %xmm0
callq 0x8150
addsd 0x8bff2(%rip), %xmm0    # 0x98428
mulsd 0x8bffa(%rip), %xmm0    # 0x98438
cvttsd2si %xmm0, %r14d
movss 0x10(%r12), %xmm0
movss 0x8bfee(%rip), %xmm2    # 0x98440
mulss %xmm2, %xmm0
movss 0x18(%r12), %xmm1
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x2e824
mulsd 0x8be9d(%rip), %xmm0    # 0x98318
addsd -0x30(%rbp), %xmm0
callq 0x8f60
addsd 0x8bf9b(%rip), %xmm0    # 0x98428
mulsd 0x8bfa3(%rip), %xmm0    # 0x98438
cvttsd2si %xmm0, %ebx
movq %r12, %rdi
callq 0xde52
movl $0xff, %ecx
andl %ecx, %ebx
shll $0x10, %ebx
andl %ecx, %r14d
shll $0x8, %r14d
orl %ebx, %r14d
andl %ecx, %r13d
orl %r14d, %r13d
cvtsd2ss 0xca385(%rip), %xmm0    # 0xd6848
movl %eax, %edi
movl %r13d, %esi
callq 0x9c9f
movq %r12, %rdi
movl %eax, %esi
callq 0xde22
leal 0x1(%r15), %eax
jmp 0xc38a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/pacman.cpp
// Function: Pacman::Pacman(int, int)
Pacman::Pacman(int x, int y) : _modelo("assets/models/pacman/idle/player_idle_0.obj", {255,211,0,255}),
							   _andando("assets/models/pacman/walk/player_walk", 6, true),
							   _parado("assets/models/pacman/idle/player_idle", 1, true),
							   _morrendo("assets/models/pacman/die/player_die", 18, false)
{
	_andando.Preload();
	_parado.Preload();
	_morrendo.Preload();
	_modelo.position = (Vector3){(float)x, 0, (float)y};
	_x = x;
	_y = y;
	_direcaoY = 0;
	_direcaoX = 0;
	_vivo = true;
	_vidas = 3;
	_velocidade = PACMAN_SPEED_DEFAULT;
	_timerAnimacao = 0.0;
	_timerScared = 0.0;
	_scaredTime = 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, -0x30(%rbp)
movl %esi, %r12d
movq %rdi, %rbx
callq 0xb1ce
leaq 0xc8f7f(%rip), %rax     # 0xd5b30
movq %rax, (%rbx)
leaq 0x8b98d(%rip), %rsi     # 0x98548
leaq -0xb8(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x8310
leaq 0x8(%rbx), %rdi
leaq -0xb8(%rbp), %rsi
movq %rdi, -0x38(%rbp)
movl $0xff00d3ff, %edx       # imm = 0xFF00D3FF
callq 0xdbf6
leaq -0xb8(%rbp), %rdi
callq 0x83a0
andl $0x0, 0x2c8(%rbx)
leaq 0x8b976(%rip), %rsi     # 0x98574
leaq -0x98(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x8310
leaq 0x2f0(%rbx), %r13
leaq -0x98(%rbp), %rsi
pushq $0x6
popq %rdx
pushq $0x1
popq %rcx
movq %r13, %rdi
callq 0xd5d0
leaq -0x98(%rbp), %rdi
callq 0x83a0
leaq 0x8b95d(%rip), %rsi     # 0x9859a
leaq -0x78(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x8310
leaq 0x320(%rbx), %r14
leaq -0x78(%rbp), %rsi
pushq $0x1
popq %rcx
movq %r14, %rdi
movl %ecx, %edx
callq 0xd5d0
leaq -0x78(%rbp), %rdi
callq 0x83a0
leaq 0x8b94e(%rip), %rsi     # 0x985c0
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x8310
leaq 0x350(%rbx), %r15
leaq -0x58(%rbp), %rsi
pushq $0x12
popq %rdx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0xd5d0
leaq -0x58(%rbp), %rdi
callq 0x83a0
movq %r13, %rdi
callq 0xd622
movq %r14, %rdi
callq 0xd622
movq %r15, %rdi
callq 0xd622
cvtsi2ss %r12d, %xmm0
cvtsi2ssl -0x30(%rbp), %xmm1
movss %xmm0, 0x18(%rbx)
andl $0x0, 0x1c(%rbx)
movss %xmm1, 0x20(%rbx)
movss %xmm0, 0x2d4(%rbx)
movss %xmm1, 0x2d8(%rbx)
andq $0x0, 0x2cc(%rbx)
movb $0x1, 0x2c0(%rbx)
movl $0x3, 0x2c4(%rbx)
movaps 0x8b810(%rip), %xmm0    # 0x98510
movups %xmm0, 0x2dc(%rbx)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq -0x58(%rbp), %rdi
jmp 0xcd62
movq %rax, %r12
jmp 0xcd67
movq %rax, %r12
leaq -0x78(%rbp), %rdi
jmp 0xcd6a
movq %rax, %r12
jmp 0xcd6f
movq %rax, %r12
leaq -0x98(%rbp), %rdi
jmp 0xcd72
movq %rax, %r12
jmp 0xcd77
movq %rax, %r12
leaq -0xb8(%rbp), %rdi
callq 0x83a0
jmp 0xcd80
movq %rax, %r12
jmp 0xcd80
movq %rax, %r12
movq %r15, %rdi
callq 0x83a0
movq %r14, %rdi
callq 0x83a0
movq %r13, %rdi
callq 0x83a0
movq -0x38(%rbp), %rdi
callq 0xdcbe
movq %rbx, %rdi
callq 0xb1fa
movq %r12, %rdi
callq 0x8ed0
// File: /workspace/github_cpp_makefile_star2_O2/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
movb $0x0, 0x2c0(%rdi)
movl 0x2c4(%rdi), %eax
testl %eax, %eax
je 0xcfbd
decl %eax
movl %eax, 0x2c4(%rdi)
andl $0x0, 0x2e0(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xc036
movss %xmm0, 0x18(%rbx)
andl $0x0, 0x1c(%rbx)
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
movss %xmm1, 0x20(%rbx)
movss %xmm0, 0x2d4(%rbx)
movss %xmm1, 0x2d8(%rbx)
andq $0x0, 0x2cc(%rbx)
leaq 0x8(%rbx), %r14
movb $0x1, 0x2c0(%rbx)
addq $0x320, %rbx            # imm = 0x320
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0xd6f2
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd72c
movq %r14, %rdi
movq %r15, %rsi
callq 0xdce4
leaq -0x38(%rbp), %rdi
callq 0x83a0
xorl %edi, %edi
callq 0xa43e
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x83a0
movq %rbx, %rdi
callq 0x8ed0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x8470
movl %r15d, 0x20(%rbx)
andl $0x0, 0x24(%rbx)
movb %r14b, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x83a0
movq %r14, %rdi
callq 0x8ed0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
xorl %r15d, %r15d
leaq -0x1c0(%rbp), %r12
leaq 0x8af25(%rip), %r14     # 0x9856f
leaq -0x48(%rbp), %r13
movl 0x20(%rbx), %eax
cmpq %rax, %r15
jae 0xd6ba
movq %r12, %rdi
callq 0x8aa0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8750
movq %rax, %rdi
leaq 0x8af79(%rip), %rsi     # 0x985ec
callq 0x8840
movq %rax, %rdi
movq %r15, %rsi
callq 0x8570
movq %rax, %rdi
movq %r14, %rsi
callq 0x8840
movq %r13, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x8d40
movq %r13, %rdi
callq 0xdda4
movq %r13, %rdi
callq 0x83a0
movq %r12, %rdi
callq 0x81a0
incq %r15
jmp 0xd64e
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x83a0
jmp 0xd6dd
movq %rax, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0x81a0
movq %rbx, %rdi
callq 0x8ed0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r15
movq %rdi, %rbx
cvttss2si 0x24(%rsi), %r14d
leaq -0x198(%rbp), %r12
movq %r12, %rdi
callq 0x8aa0
movq %r12, %rdi
movq %r15, %rsi
callq 0x8750
leaq 0x8ae81(%rip), %rsi     # 0x985ec
movq %rax, %rdi
callq 0x8840
movq %rax, %rdi
movl %r14d, %esi
callq 0x8e80
leaq 0x8adea(%rip), %rsi     # 0x9856f
movq %rax, %rdi
callq 0x8840
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x8d40
leaq -0x198(%rbp), %rdi
callq 0x81a0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x198(%rbp), %rdi
callq 0x81a0
movq %rbx, %rdi
callq 0x8ed0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups 0x1c(%rdi), %xmm2
movups %xmm2, -0x34(%rbp)
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movups -0x34(%rbp), %xmm0
movups %xmm0, 0x1c(%rsp)
movaps -0x50(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2d524
leaq 0x20673e(%rip), %r14    # 0x2140c0
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0xd9a4
movq 0x10(%r15), %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0xd985
callq 0x2d820
leaq 0x206710(%rip), %rdi    # 0x2140c0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd9da
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdi)
movl $0xf5f5f500, 0x8(%rdi)  # imm = 0xF5F5F500
movw $0xff, 0xc(%rdi)
movaps 0x8aa90(%rip), %xmm0    # 0x98670
movups %xmm0, 0x10(%rdi)
movaps 0x8aa95(%rip), %xmm0    # 0x98680
movups %xmm0, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x8(%rdi)
jne 0xdd08
movq %rbx, %rdi
callq 0xee16
movq %rax, (%rbx)
movb $0x1, %al
movb %al, 0x8(%rbx)
movb %al, 0xd(%rbx)
leaq 0x2063c9(%rip), %rdi    # 0x2140e0
movq %r14, %rsi
callq 0xdf4e
leaq 0x2063c2(%rip), %rcx    # 0x2140e8
cmpq %rcx, %rax
jne 0xdd4b
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8ad0
movq %r15, %rdi
callq 0xdda4
leaq -0x38(%rbp), %rdi
callq 0x83a0
leaq 0x20638e(%rip), %r15    # 0x2140e0
movq %r15, %rdi
movq %r14, %rsi
callq 0xde66
movl 0x9(%rbx), %ecx
movl %ecx, 0x138(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0xde66
addq $0x38, %rbx
movl $0x280, %edx            # imm = 0x280
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8690
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x83a0
movq %rbx, %rdi
callq 0x8ed0
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::Init(int, int, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Init(int screenWidth, int screenHeight, bool fullscreen, std::string windowTitle){
        if(fullscreen)
            ToggleFullscreen();

        #ifdef NDEBUG
        SetTraceLog(0);
        ShowLogo();
        #else
        SetTraceLog(LOG_DEBUG|LOG_ERROR|LOG_WARNING|LOG_INFO);
        #endif
        
        SetConfigFlags(FLAG_MSAA_4X_HINT);
        InitWindow(screenWidth, screenHeight, windowTitle.c_str());
        
        Image icon = LoadImage("assets/interface/pacman_icon.png");         
        SetWindowIcon(icon);
        UnloadImage(icon);

        #ifdef NDEBUG
        SetTargetFPS(60);
        #else
        SetTargetFPS(0);
        #endif
        
        LoadShaders();
        SetResolution(screenWidth, screenHeight);

        Image blackImg = GenImageColor(2,2,BLACK);
        _blackTexture = LoadTextureFromImage(blackImg);
        UnloadImage(blackImg);

        _maskTexture = LoadTexture(MASK_TEXTURE_PATH);

        _isInitialized = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movl %esi, %ebx
movl %edi, %r14d
testl %edx, %edx
je 0xe3ce
callq 0x2cb00
pushq $0xf
popq %rdi
callq 0x7c62b
pushq $0x20
popq %rdi
callq 0x2ec65
movq (%r15), %rdx
movl %r14d, %edi
movl %ebx, %esi
callq 0x2c99d
leaq 0x89fde(%rip), %rsi     # 0x983d0
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x6e894
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x2cba6
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x6f0e9
xorl %edi, %edi
callq 0x2e76a
callq 0xe4d4
movl %r14d, %edi
movl %ebx, %esi
callq 0xe5e7
leaq -0x48(%rbp), %rbx
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
movl $0xff000000, %ecx       # imm = 0xFF000000
callq 0x75554
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
leaq -0x2c(%rbp), %r14
movq %r14, %rdi
callq 0x6f014
movl 0x10(%r14), %eax
movl %eax, 0x2060c4(%rip)    # 0x214540
movups (%r14), %xmm0
movups %xmm0, 0x2060a9(%rip)   # 0x214530
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x6f0e9
leaq 0x8a1ee(%rip), %rsi     # 0x98691
leaq -0x2c(%rbp), %rbx
movq %rbx, %rdi
callq 0x6ef55
movl 0x10(%rbx), %eax
movl %eax, 0x20609c(%rip)    # 0x214554
movups (%rbx), %xmm0
movups %xmm0, 0x206082(%rip)   # 0x214544
movb $0x1, 0x205c5b(%rip)    # 0x214124
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x8a1c6(%rip), %rbx     # 0x986af
leaq 0x8a1d8(%rip), %rdx     # 0x986c8
leaq -0x94(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21308
leaq 0x205dc7(%rip), %rdi    # 0x2142d0
movl $0x84, %edx
movq %r14, %rsi
callq 0x8690
leaq 0x8a1cb(%rip), %rdx     # 0x986e8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21308
leaq 0x205c09(%rip), %rdi    # 0x214138
movl $0x84, %edx
movq %r14, %rsi
callq 0x8690
leaq 0x8a1c0(%rip), %rdx     # 0x98703
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21308
leaq 0x205e03(%rip), %rdi    # 0x214358
movl $0x84, %edx
movq %r14, %rsi
callq 0x8690
leaq 0x8a1b3(%rip), %rdx     # 0x9871c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21308
leaq 0x205e65(%rip), %rdi    # 0x2143e0
movl $0x84, %edx
movq %r14, %rsi
callq 0x8690
leaq 0x8a1a6(%rip), %rbx     # 0x98735
leaq 0x8a1bb(%rip), %rdx     # 0x98751
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21308
leaq 0x205c18(%rip), %rdi    # 0x2141c0
movl $0x84, %edx
movq %r14, %rsi
callq 0x8690
leaq 0x8a1b0(%rip), %rdx     # 0x9876c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21308
leaq 0x205c7a(%rip), %rdi    # 0x214248
movl $0x84, %edx
movq %r14, %rsi
callq 0x8690
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::Quit()
void Quit(){
        if(_isInitialized){
            UnloadShader(_outlineFilter);
            UnloadShader(_maskShader);
            UnloadShader(_colorShader);
            UnloadShader(_blurPass);
            UnloadShader(_screenShader);
            UnloadShader(_copyRTShader);

            UnloadTexture(_blackTexture);
        
            UnloadRenderTexture(_baseRT);
            UnloadRenderTexture(_tempRT);
            UnloadRenderTexture(_blurRT);
            UnloadRenderTexture(_vBlurRT);

            CloseWindow();
        }
        _isInitialized = false;
    }

// Assembly:
cmpb $0x1, 0x205948(%rip)    # 0x214124
jne 0xe938
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x205adc(%rip), %rsi    # 0x2142d0
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
leaq 0x2059b6(%rip), %rsi    # 0x2141c0
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
leaq 0x205a28(%rip), %rsi    # 0x214248
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
leaq 0x205902(%rip), %rsi    # 0x214138
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
leaq 0x205b0c(%rip), %rsi    # 0x214358
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
leaq 0x205b7e(%rip), %rsi    # 0x2143e0
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
movl 0x205cc9(%rip), %eax    # 0x214540
movl %eax, 0x10(%rsp)
movups 0x205cae(%rip), %xmm0   # 0x214530
movups %xmm0, (%rsp)
callq 0x6f104
movups 0x205bfa(%rip), %xmm0   # 0x21448c
movups %xmm0, 0x1c(%rsp)
movups 0x205be2(%rip), %xmm0   # 0x214480
movups %xmm0, 0x10(%rsp)
movups 0x205bc6(%rip), %xmm0   # 0x214470
movups %xmm0, (%rsp)
callq 0x6f136
movups 0x205c02(%rip), %xmm0   # 0x2144bc
movups %xmm0, 0x1c(%rsp)
movups 0x205bea(%rip), %xmm0   # 0x2144b0
movups %xmm0, 0x10(%rsp)
movups 0x205bce(%rip), %xmm0   # 0x2144a0
movups %xmm0, (%rsp)
callq 0x6f136
movups 0x205c0a(%rip), %xmm0   # 0x2144ec
movups %xmm0, 0x1c(%rsp)
movups 0x205bf2(%rip), %xmm0   # 0x2144e0
movups %xmm0, 0x10(%rsp)
movups 0x205bd6(%rip), %xmm0   # 0x2144d0
movups %xmm0, (%rsp)
callq 0x6f136
movups 0x205c12(%rip), %xmm0   # 0x21451c
movups %xmm0, 0x1c(%rsp)
movups 0x205bfa(%rip), %xmm0   # 0x214510
movups %xmm0, 0x10(%rsp)
movups 0x205bde(%rip), %xmm0   # 0x214500
movups %xmm0, (%rsp)
callq 0x6f136
callq 0x2ca59
addq $0x90, %rsp
popq %rbp
movb $0x0, 0x2057e5(%rip)    # 0x214124
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl $0x2, %edi
ja 0xe956
pushq $0x3
popq %rax
subl %edi, %eax
movl %eax, 0xc7f2c(%rip)     # 0xd687c
movl %edi, 0x2057da(%rip)    # 0x214130
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
cmpb $0x1, 0x2057be(%rip)    # 0x214124
jne 0xe9b8
movups 0x205b7d(%rip), %xmm0   # 0x2144ec
movups %xmm0, 0x1c(%rsp)
movups 0x205b65(%rip), %xmm0   # 0x2144e0
movups %xmm0, 0x10(%rsp)
movups 0x205b49(%rip), %xmm0   # 0x2144d0
movups %xmm0, (%rsp)
callq 0x6f136
movups 0x205b85(%rip), %xmm0   # 0x21451c
movups %xmm0, 0x1c(%rsp)
movups 0x205b6d(%rip), %xmm0   # 0x214510
movups %xmm0, 0x10(%rsp)
movups 0x205b51(%rip), %xmm0   # 0x214500
movups %xmm0, (%rsp)
callq 0x6f136
movl 0x20576a(%rip), %eax    # 0x214128
movl 0xc7eb8(%rip), %ecx     # 0xd687c
cltd
idivl %ecx
movl %eax, %esi
movl 0x20575d(%rip), %eax    # 0x21412c
cltd
idivl %ecx
leaq -0x34(%rbp), %rbx
movq %rbx, %rdi
movl %eax, %edx
callq 0x6f08c
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x1c(%rbx), %xmm2
movups %xmm2, 0x205afa(%rip)   # 0x2144ec
movups %xmm1, 0x205ae7(%rip)   # 0x2144e0
movups %xmm0, 0x205ad0(%rip)   # 0x2144d0
movl 0x205722(%rip), %eax    # 0x214128
movl 0xc7e70(%rip), %ecx     # 0xd687c
cltd
idivl %ecx
movl %eax, %esi
movl 0x205715(%rip), %eax    # 0x21412c
cltd
idivl %ecx
movq %rbx, %rdi
movl %eax, %edx
callq 0x6f08c
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x1c(%rbx), %xmm2
movups %xmm2, 0x205ae6(%rip)   # 0x21451c
movups %xmm1, 0x205ad3(%rip)   # 0x214510
movups %xmm0, 0x205abc(%rip)   # 0x214500
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x90, %rsp
cmpb $0x1, 0x2053c6(%rip)    # 0x214124
jne 0xede8
leaq 0x205565(%rip), %rsi    # 0x2142d0
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
leaq 0x20543f(%rip), %rsi    # 0x2141c0
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
leaq 0x2054b1(%rip), %rsi    # 0x214248
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
leaq 0x20538b(%rip), %rsi    # 0x214138
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
leaq 0x205595(%rip), %rsi    # 0x214358
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
leaq 0x205607(%rip), %rsi    # 0x2143e0
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x21829
callq 0xe4d4
addq $0x90, %rsp
popq %rbp
jmp 0xea4b
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movss %xmm2, -0x8(%rbp)
movss %xmm1, -0x10(%rbp)
movaps %xmm0, -0x40(%rbp)
movss 0x205293(%rip), %xmm3   # 0x214118
addss %xmm0, %xmm3
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
addss 0x205284(%rip), %xmm2   # 0x21411c
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movaps %xmm3, -0x20(%rbp)
movss 0x205279(%rip), %xmm0   # 0x214120
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movsd 0xc7998(%rip), %xmm0    # 0xd6850
movaps %xmm0, -0x30(%rbp)
movss 0xc7994(%rip), %xmm0    # 0xd6858
movss %xmm0, -0xc(%rbp)
callq 0x2e7fe
movaps %xmm0, %xmm4
mulss -0x8(%rbp), %xmm4
movaps -0x30(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
movaps -0x20(%rbp), %xmm2
movss -0x4(%rbp), %xmm3
callq 0x9c55
movlps %xmm0, 0xc795c(%rip)    # 0xd6850
movss %xmm1, 0xc795c(%rip)    # 0xd6858
movsd 0xc7958(%rip), %xmm0    # 0xd685c
movaps %xmm0, -0x20(%rbp)
movss 0xc7954(%rip), %xmm0    # 0xd6864
movss %xmm0, -0x4(%rbp)
callq 0x2e7fe
movss -0x8(%rbp), %xmm4
mulss %xmm0, %xmm4
movaps -0x20(%rbp), %xmm0
movss -0x4(%rbp), %xmm1
movaps -0x40(%rbp), %xmm2
movss -0x10(%rbp), %xmm3
callq 0x9c55
movlps %xmm0, 0xc791b(%rip)    # 0xd685c
movss %xmm1, 0xc791b(%rip)    # 0xd6864
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0xc78e4(%rip), %rdi     # 0xd6850
callq 0x28dfd
cmpb $0x1, 0x2051ac(%rip)    # 0x214124
jne 0xefd4
callq 0x2ce22
movl $0xff000000, %edi       # imm = 0xFF000000
callq 0x2cded
leaq 0x228548(%rip), %rax    # 0x2374d8
movl $0xbe2, %edi            # imm = 0xBE2
callq *(%rax)
callq 0xefd6
callq 0xf347
callq 0xf5b9
leaq 0x22877b(%rip), %rax    # 0x237728
movl $0xbe2, %edi            # imm = 0xBE2
callq *(%rax)
callq 0xfb65
leaq 0xc7890(%rip), %rdi     # 0xd6850
callq 0xd938
xorl %edi, %edi
xorl %esi, %esi
callq 0x5ccdd
popq %rbp
jmp 0x2ceea
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xb0, %rsp
leaq 0x204d8d(%rip), %rsi    # 0x214358
movl $0x84, %ecx
movq %rsp, %rdi
rep  movsb (%rsi), %es:(%rdi)
callq 0x2185b
leaq 0x227acf(%rip), %rax    # 0x2370b0
movl $0x84c1, %edi           # imm = 0x84C1
callq *(%rax)
leaq 0x2276b1(%rip), %rax    # 0x236ca0
movl 0x204edf(%rip), %esi    # 0x2144d4
movl $0xde1, %edi            # imm = 0xDE1
callq *(%rax)
movl 0x204e82(%rip), %eax    # 0x214484
movl %eax, -0x10(%rbp)
movups 0x204e68(%rip), %xmm0   # 0x214474
movaps %xmm0, -0x20(%rbp)
cvtsi2ssl 0x204b10(%rip), %xmm1 # 0x214128
movl 0x204b0e(%rip), %eax    # 0x21412c
cvtsi2ss %eax, %xmm0
negl %eax
cvtsi2ss %eax, %xmm2
movl -0x10(%rbp), %eax
movl %eax, 0x10(%rsp)
movaps -0x20(%rbp), %xmm3
movups %xmm3, (%rsp)
movaps %xmm1, %xmm3
unpcklps %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
pushq $-0x1
popq %rdi
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
xorps %xmm4, %xmm4
xorps %xmm5, %xmm5
callq 0x7693b
addq $0xb0, %rsp
popq %rbp
jmp 0x2189e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x204dd9(%rip), %rdi    # 0x2145c0
movq %rbx, %rsi
callq 0x10126
leaq 0x204dd2(%rip), %rcx    # 0x2145c8
cmpq %rcx, %rax
jne 0xf85a
leaq 0x204dbe(%rip), %rdi    # 0x2145c0
movq %rbx, %rsi
callq 0xfeae
movq %rax, %r14
movq (%rbx), %rsi
leaq -0x44(%rbp), %r15
movq %r15, %rdi
callq 0x6ef55
movl 0x10(%r15), %eax
movl %eax, 0x10(%r14)
movups (%r15), %xmm0
movups %xmm0, (%r14)
movups (%r14), %xmm0
movaps %xmm0, -0x30(%rbp)
movl 0x10(%r14), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, 0x10(%rsp)
movaps -0x30(%rbp), %xmm0
movups %xmm0, (%rsp)
pushq $0x2
popq %rdi
callq 0x76473
movq %r14, %rdi
callq 0x76459
leaq 0x204d5f(%rip), %rdi    # 0x2145c0
movq %rbx, %rsi
callq 0xfeae
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x204d19(%rip)    # 0x2145a0
jne 0xf8b1
movq 0x204d08(%rip), %rax    # 0x214598
movq %rax, 0x20(%rsp)
movups 0x204cec(%rip), %xmm0   # 0x214588
movups %xmm0, 0x10(%rsp)
movups 0x204cd0(%rip), %xmm0   # 0x214578
movups %xmm0, (%rsp)
callq 0x5c2b5
movb $0x1, 0x204ce8(%rip)    # 0x2145a0
movq (%rbx), %rsi
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x5af4d
movq 0x20(%rbx), %rax
movq %rax, 0x204cc6(%rip)    # 0x214598
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x204ca8(%rip)   # 0x214588
movups %xmm0, 0x204c91(%rip)   # 0x214578
leaq 0x204c8a(%rip), %rbx    # 0x214578
movl 0x204c94(%rip), %eax    # 0x214588
movl %eax, 0x10(%rsp)
movups 0x204c79(%rip), %xmm0   # 0x214578
movups %xmm0, (%rsp)
pushq $0x2
popq %rdi
callq 0x76473
movq %rbx, %rdi
callq 0x76459
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UIElement::UIElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float, float, float, float)
UIElement(std::string ImagePath, float X, float Y, float Width, float Height){
        string = ImagePath;
        type = ElementType::UIImage;
        x = X;
        y = Y;
        width = Width;
        height = Height;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm3, -0x20(%rbp)
movss %xmm2, -0x1c(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %r14, %rdi
callq 0x8470
movl $0x2, (%rbx)
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x4(%rbx)
movss -0x18(%rbp), %xmm0
movss %xmm0, 0x8(%rbx)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0xc(%rbx)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x83a0
movq %rbx, %rdi
callq 0x8ed0
nop
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UIElement::UIElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float, float, float, float, Color, bool)
UIElement(std::string Text, float X, float Y, float Size, float Spacing, Color ColorTint, bool Centered){
        colorTint = ColorTint;
        string = Text;
        type = Centered? ElementType::UITextCentered : ElementType::UIText;
        x = X;
        y = Y;
        width = Spacing;
        height = Size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movss %xmm3, -0x24(%rbp)
movss %xmm2, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm0, -0x1c(%rbp)
movq %rdi, %r14
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
leaq 0x18(%rdi), %r15
movb $0x0, 0x28(%rdi)
movl %edx, 0x38(%rdi)
movq %r15, %rdi
callq 0x8470
movzbl %bl, %eax
movl %eax, (%r14)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x4(%r14)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0x8(%r14)
movss -0x24(%rbp), %xmm0
movss %xmm0, 0xc(%r14)
movss -0x28(%rbp), %xmm0
movss %xmm0, 0x10(%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x83a0
movq %rbx, %rdi
callq 0x8ed0
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/enemies/blinky.cpp
// Function: Blinky::SetGoal(int&, int&, int, int, int, int)
void Blinky::SetGoal(int &goalX, int &goalY, int pacX, int pacY,int dirX, int dirY){
    if(_alive){
        if(!_scared){
            //Depois de um tempo o fantasma vai para o seu canto
            if(_scatter){
                goalX = 1;
                goalY = 1;
                if(_timerScatter > 0){
                    _timerScatter -= 5*GetFrameTime();
                    
                }
            }else{
                //segue o pacman
                goalX = pacX;
                goalY = pacY;
            }
        }else{
            //Quando ele esta com medo ele tambem vai para o seu canto
            goalX = 1;
            goalY = 1;
        }
    }else{
        goalX = 10;
        goalY = 10;
    }
}

// Assembly:
cmpb $0x1, 0x2d9(%rdi)
jne 0x107fc
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc865b(%rip), %rax     # 0xd8e49
cmpb $0x0, (%rax)
je 0x10804
pushq $0x1
popq %rax
movl %eax, (%rsi)
movl %eax, (%rdx)
jmp 0x1084b
pushq $0xa
popq %rax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x10846
pushq $0x1
popq %rax
movl %eax, (%rsi)
movl %eax, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x1084b
callq 0x2e7fe
mulss 0x87fac(%rip), %xmm0    # 0x987e0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x1084b
movl %ecx, (%rsi)
movl %r8d, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/enemies/clyde.cpp
// Function: Clyde::SetGoal(int&, int&, int, int, int, int)
void Clyde::SetGoal(int &goalX, int &goalY, int pacX, int pacY,int dirX, int dirY){
    if(_alive){
        if(!_scared){
            if(_scatter){
                goalX = LARGURA - 2;
                goalY = ALTURA - 2;
                if(_timerScatter > 0){
                    _timerScatter -= 5*GetFrameTime();
                    
                }
            }//Se a distancia entre o Clyde e o pacman for menor que 8 ele volta pro cantinho dele
            else if(abs(pacX - _x) + abs(pacY - _y) >= 8){
                goalX = pacX;
                goalY = pacY;
            }
            else{
                goalX = LARGURA - 2;
                goalY = ALTURA - 2;    
            }
        }else{
            goalX = LARGURA - 2;
            goalY = ALTURA - 2;
        }
    }else{
        goalX = 10;
        goalY = 10;
    }
}

// Assembly:
cmpb $0x1, 0x2d9(%rdi)
jne 0x108c6
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc859b(%rip), %rax     # 0xd8e49
cmpb $0x0, (%rax)
je 0x108ce
movl $0x13, (%rsi)
movl $0x19, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0xa
popq %rax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x10915
movl $0x13, (%rsi)
movl $0x19, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x108bf
callq 0x2e7fe
mulss 0x87edd(%rip), %xmm0    # 0x987e0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x108bf
movl %ecx, %eax
subl 0x2c8(%rbx), %eax
movl %eax, %edi
negl %edi
cmovsl %eax, %edi
movl %r8d, %eax
subl 0x2cc(%rbx), %eax
movl %eax, %r9d
negl %r9d
cmovsl %eax, %r9d
addl %edi, %r9d
cmpl $0x8, %r9d
jb 0x108b3
movl %ecx, (%rsi)
movl %r8d, (%rdx)
jmp 0x108bf